]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
IB: Replace remaining __FUNCTION__ occurrences with __func__
authorHarvey Harrison <harvey.harrison@gmail.com>
Thu, 17 Apr 2008 04:01:10 +0000 (21:01 -0700)
committerRoland Dreier <rolandd@cisco.com>
Thu, 17 Apr 2008 04:01:10 +0000 (21:01 -0700)
__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>
26 files changed:
drivers/infiniband/hw/amso1100/c2_ae.c
drivers/infiniband/hw/amso1100/c2_alloc.c
drivers/infiniband/hw/amso1100/c2_provider.c
drivers/infiniband/hw/amso1100/c2_qp.c
drivers/infiniband/hw/amso1100/c2_rnic.c
drivers/infiniband/hw/amso1100/c2_vq.c
drivers/infiniband/hw/cxgb3/cxio_dbg.c
drivers/infiniband/hw/cxgb3/cxio_hal.c
drivers/infiniband/hw/cxgb3/cxio_resource.c
drivers/infiniband/hw/cxgb3/iwch.c
drivers/infiniband/hw/cxgb3/iwch_cm.c
drivers/infiniband/hw/cxgb3/iwch_cm.h
drivers/infiniband/hw/cxgb3/iwch_cq.c
drivers/infiniband/hw/cxgb3/iwch_ev.c
drivers/infiniband/hw/cxgb3/iwch_mem.c
drivers/infiniband/hw/cxgb3/iwch_provider.c
drivers/infiniband/hw/cxgb3/iwch_provider.h
drivers/infiniband/hw/cxgb3/iwch_qp.c
drivers/infiniband/hw/ehca/ehca_tools.h
drivers/infiniband/hw/nes/nes.c
drivers/infiniband/hw/nes/nes.h
drivers/infiniband/hw/nes/nes_cm.c
drivers/infiniband/hw/nes/nes_hw.c
drivers/infiniband/hw/nes/nes_nic.c
drivers/infiniband/hw/nes/nes_utils.c
drivers/infiniband/hw/nes/nes_verbs.c

index 07ce952699babb0e860a4f0b2768c1d9ee6d43b8..62af74295dbeb814a2d6158d4e7a274c0318ca8b 100644 (file)
@@ -61,7 +61,7 @@ static int c2_convert_cm_status(u32 c2_status)
        default:
                printk(KERN_ERR PFX
                       "%s - Unable to convert CM status: %d\n",
-                      __FUNCTION__, c2_status);
+                      __func__, c2_status);
                return -EIO;
        }
 }
@@ -193,7 +193,7 @@ void c2_ae_event(struct c2_dev *c2dev, u32 mq_index)
                pr_debug("%s: event = %s, user_context=%llx, "
                        "resource_type=%x, "
                        "resource=%x, qp_state=%s\n",
-                       __FUNCTION__,
+                       __func__,
                        to_event_str(event_id),
                        (unsigned long long) wr->ae.ae_generic.user_context,
                        be32_to_cpu(wr->ae.ae_generic.resource_type),
@@ -259,7 +259,7 @@ void c2_ae_event(struct c2_dev *c2dev, u32 mq_index)
                        BUG_ON(1);
                        pr_debug("%s:%d Unexpected event_id=%d on QP=%p, "
                                "CM_ID=%p\n",
-                               __FUNCTION__, __LINE__,
+                               __func__, __LINE__,
                                event_id, qp, cm_id);
                        break;
                }
@@ -276,7 +276,7 @@ void c2_ae_event(struct c2_dev *c2dev, u32 mq_index)
                pr_debug("C2_RES_IND_EP event_id=%d\n", event_id);
                if (event_id != CCAE_CONNECTION_REQUEST) {
                        pr_debug("%s: Invalid event_id: %d\n",
-                               __FUNCTION__, event_id);
+                               __func__, event_id);
                        break;
                }
                cm_event.event = IW_CM_EVENT_CONNECT_REQUEST;
index 02091e69e206a683e474e9db9a8cf88d4cc2fbd1..e9110163aeffc65c79858b5fff83d710293e2136 100644 (file)
@@ -113,7 +113,7 @@ __be16 *c2_alloc_mqsp(struct c2_dev *c2dev, struct sp_chunk *head,
                *dma_addr = head->dma_addr +
                            ((unsigned long) &(head->shared_ptr[mqsp]) -
                             (unsigned long) head);
-               pr_debug("%s addr %p dma_addr %llx\n", __FUNCTION__,
+               pr_debug("%s addr %p dma_addr %llx\n", __func__,
                         &(head->shared_ptr[mqsp]), (unsigned long long) *dma_addr);
                return (__force __be16 *) &(head->shared_ptr[mqsp]);
        }
index 7a6cece6ea9d1ba0060ee630b3ab7a5931f8f638..21fb46d39319c27df354784c1d6696ed6a840fc3 100644 (file)
@@ -67,7 +67,7 @@ static int c2_query_device(struct ib_device *ibdev,
 {
        struct c2_dev *c2dev = to_c2dev(ibdev);
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        *props = c2dev->props;
        return 0;
@@ -76,7 +76,7 @@ static int c2_query_device(struct ib_device *ibdev,
 static int c2_query_port(struct ib_device *ibdev,
                         u8 port, struct ib_port_attr *props)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        props->max_mtu = IB_MTU_4096;
        props->lid = 0;
@@ -102,14 +102,14 @@ static int c2_modify_port(struct ib_device *ibdev,
                          u8 port, int port_modify_mask,
                          struct ib_port_modify *props)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        return 0;
 }
 
 static int c2_query_pkey(struct ib_device *ibdev,
                         u8 port, u16 index, u16 * pkey)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        *pkey = 0;
        return 0;
 }
@@ -119,7 +119,7 @@ static int c2_query_gid(struct ib_device *ibdev, u8 port,
 {
        struct c2_dev *c2dev = to_c2dev(ibdev);
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        memset(&(gid->raw[0]), 0, sizeof(gid->raw));
        memcpy(&(gid->raw[0]), c2dev->pseudo_netdev->dev_addr, 6);
 
@@ -134,7 +134,7 @@ static struct ib_ucontext *c2_alloc_ucontext(struct ib_device *ibdev,
 {
        struct c2_ucontext *context;
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        context = kmalloc(sizeof(*context), GFP_KERNEL);
        if (!context)
                return ERR_PTR(-ENOMEM);
@@ -144,14 +144,14 @@ static struct ib_ucontext *c2_alloc_ucontext(struct ib_device *ibdev,
 
 static int c2_dealloc_ucontext(struct ib_ucontext *context)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        kfree(context);
        return 0;
 }
 
 static int c2_mmap_uar(struct ib_ucontext *context, struct vm_area_struct *vma)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        return -ENOSYS;
 }
 
@@ -162,7 +162,7 @@ static struct ib_pd *c2_alloc_pd(struct ib_device *ibdev,
        struct c2_pd *pd;
        int err;
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        pd = kmalloc(sizeof(*pd), GFP_KERNEL);
        if (!pd)
@@ -187,7 +187,7 @@ static struct ib_pd *c2_alloc_pd(struct ib_device *ibdev,
 
 static int c2_dealloc_pd(struct ib_pd *pd)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        c2_pd_free(to_c2dev(pd->device), to_c2pd(pd));
        kfree(pd);
 
@@ -196,13 +196,13 @@ static int c2_dealloc_pd(struct ib_pd *pd)
 
 static struct ib_ah *c2_ah_create(struct ib_pd *pd, struct ib_ah_attr *ah_attr)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        return ERR_PTR(-ENOSYS);
 }
 
 static int c2_ah_destroy(struct ib_ah *ah)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        return -ENOSYS;
 }
 
@@ -230,7 +230,7 @@ struct ib_qp *c2_get_qp(struct ib_device *device, int qpn)
 
        qp = c2_find_qpn(c2dev, qpn);
        pr_debug("%s Returning QP=%p for QPN=%d, device=%p, refcount=%d\n",
-               __FUNCTION__, qp, qpn, device,
+               __func__, qp, qpn, device,
                (qp?atomic_read(&qp->refcount):0));
 
        return (qp?&qp->ibqp:NULL);
@@ -243,13 +243,13 @@ static struct ib_qp *c2_create_qp(struct ib_pd *pd,
        struct c2_qp *qp;
        int err;
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        switch (init_attr->qp_type) {
        case IB_QPT_RC:
                qp = kzalloc(sizeof(*qp), GFP_KERNEL);
                if (!qp) {
-                       pr_debug("%s: Unable to allocate QP\n", __FUNCTION__);
+                       pr_debug("%s: Unable to allocate QP\n", __func__);
                        return ERR_PTR(-ENOMEM);
                }
                spin_lock_init(&qp->lock);
@@ -266,7 +266,7 @@ static struct ib_qp *c2_create_qp(struct ib_pd *pd,
 
                break;
        default:
-               pr_debug("%s: Invalid QP type: %d\n", __FUNCTION__,
+               pr_debug("%s: Invalid QP type: %d\n", __func__,
                        init_attr->qp_type);
                return ERR_PTR(-EINVAL);
                break;
@@ -285,7 +285,7 @@ static int c2_destroy_qp(struct ib_qp *ib_qp)
        struct c2_qp *qp = to_c2qp(ib_qp);
 
        pr_debug("%s:%u qp=%p,qp->state=%d\n",
-               __FUNCTION__, __LINE__,ib_qp,qp->state);
+               __func__, __LINE__, ib_qp, qp->state);
        c2_free_qp(to_c2dev(ib_qp->device), qp);
        kfree(qp);
        return 0;
@@ -300,13 +300,13 @@ static struct ib_cq *c2_create_cq(struct ib_device *ibdev, int entries, int vect
 
        cq = kmalloc(sizeof(*cq), GFP_KERNEL);
        if (!cq) {
-               pr_debug("%s: Unable to allocate CQ\n", __FUNCTION__);
+               pr_debug("%s: Unable to allocate CQ\n", __func__);
                return ERR_PTR(-ENOMEM);
        }
 
        err = c2_init_cq(to_c2dev(ibdev), entries, NULL, cq);
        if (err) {
-               pr_debug("%s: error initializing CQ\n", __FUNCTION__);
+               pr_debug("%s: error initializing CQ\n", __func__);
                kfree(cq);
                return ERR_PTR(err);
        }
@@ -318,7 +318,7 @@ static int c2_destroy_cq(struct ib_cq *ib_cq)
 {
        struct c2_cq *cq = to_c2cq(ib_cq);
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        c2_free_cq(to_c2dev(ib_cq->device), cq);
        kfree(cq);
@@ -400,7 +400,7 @@ static struct ib_mr *c2_reg_phys_mr(struct ib_pd *ib_pd,
        mr->umem = NULL;
        pr_debug("%s - page shift %d, pbl_depth %d, total_len %u, "
                "*iova_start %llx, first pa %llx, last pa %llx\n",
-               __FUNCTION__, page_shift, pbl_depth, total_len,
+               __func__, page_shift, pbl_depth, total_len,
                (unsigned long long) *iova_start,
                (unsigned long long) page_list[0],
                (unsigned long long) page_list[pbl_depth-1]);
@@ -422,7 +422,7 @@ static struct ib_mr *c2_get_dma_mr(struct ib_pd *pd, int acc)
        struct ib_phys_buf bl;
        u64 kva = 0;
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        /* AMSO1100 limit */
        bl.size = 0xffffffff;
@@ -442,7 +442,7 @@ static struct ib_mr *c2_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
        struct c2_pd *c2pd = to_c2pd(pd);
        struct c2_mr *c2mr;
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        c2mr = kmalloc(sizeof(*c2mr), GFP_KERNEL);
        if (!c2mr)
@@ -506,7 +506,7 @@ static int c2_dereg_mr(struct ib_mr *ib_mr)
        struct c2_mr *mr = to_c2mr(ib_mr);
        int err;
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        err = c2_stag_dealloc(to_c2dev(ib_mr->device), ib_mr->lkey);
        if (err)
@@ -523,14 +523,14 @@ static int c2_dereg_mr(struct ib_mr *ib_mr)
 static ssize_t show_rev(struct class_device *cdev, char *buf)
 {
        struct c2_dev *dev = container_of(cdev, struct c2_dev, ibdev.class_dev);
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        return sprintf(buf, "%x\n", dev->props.hw_ver);
 }
 
 static ssize_t show_fw_ver(struct class_device *cdev, char *buf)
 {
        struct c2_dev *dev = container_of(cdev, struct c2_dev, ibdev.class_dev);
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        return sprintf(buf, "%x.%x.%x\n",
                       (int) (dev->props.fw_ver >> 32),
                       (int) (dev->props.fw_ver >> 16) & 0xffff,
@@ -539,13 +539,13 @@ static ssize_t show_fw_ver(struct class_device *cdev, char *buf)
 
 static ssize_t show_hca(struct class_device *cdev, char *buf)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        return sprintf(buf, "AMSO1100\n");
 }
 
 static ssize_t show_board(struct class_device *cdev, char *buf)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        return sprintf(buf, "%.*s\n", 32, "AMSO1100 Board ID");
 }
 
@@ -575,13 +575,13 @@ static int c2_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
 
 static int c2_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        return -ENOSYS;
 }
 
 static int c2_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        return -ENOSYS;
 }
 
@@ -592,13 +592,13 @@ static int c2_process_mad(struct ib_device *ibdev,
                          struct ib_grh *in_grh,
                          struct ib_mad *in_mad, struct ib_mad *out_mad)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        return -ENOSYS;
 }
 
 static int c2_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        /* Request a connection */
        return c2_llp_connect(cm_id, iw_param);
@@ -606,7 +606,7 @@ static int c2_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param)
 
 static int c2_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        /* Accept the new connection */
        return c2_llp_accept(cm_id, iw_param);
@@ -616,7 +616,7 @@ static int c2_reject(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
 {
        int err;
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        err = c2_llp_reject(cm_id, pdata, pdata_len);
        return err;
@@ -626,10 +626,10 @@ static int c2_service_create(struct iw_cm_id *cm_id, int backlog)
 {
        int err;
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        err = c2_llp_service_create(cm_id, backlog);
        pr_debug("%s:%u err=%d\n",
-               __FUNCTION__, __LINE__,
+               __func__, __LINE__,
                err);
        return err;
 }
@@ -637,7 +637,7 @@ static int c2_service_create(struct iw_cm_id *cm_id, int backlog)
 static int c2_service_destroy(struct iw_cm_id *cm_id)
 {
        int err;
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
 
        err = c2_llp_service_destroy(cm_id);
 
@@ -743,7 +743,7 @@ static struct net_device *c2_pseudo_netdev_init(struct c2_dev *c2dev)
        netdev = alloc_netdev(sizeof(*netdev), name, setup);
        if (!netdev) {
                printk(KERN_ERR PFX "%s -  etherdev alloc failed",
-                       __FUNCTION__);
+                       __func__);
                return NULL;
        }
 
@@ -780,7 +780,7 @@ int c2_register_device(struct c2_dev *dev)
        if (ret)
                goto out2;
 
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        strlcpy(dev->ibdev.name, "amso%d", IB_DEVICE_NAME_MAX);
        dev->ibdev.owner = THIS_MODULE;
        dev->ibdev.uverbs_cmd_mask =
@@ -873,13 +873,13 @@ out1:
 out2:
        free_netdev(dev->pseudo_netdev);
 out3:
-       pr_debug("%s:%u ret=%d\n", __FUNCTION__, __LINE__, ret);
+       pr_debug("%s:%u ret=%d\n", __func__, __LINE__, ret);
        return ret;
 }
 
 void c2_unregister_device(struct c2_dev *dev)
 {
-       pr_debug("%s:%u\n", __FUNCTION__, __LINE__);
+       pr_debug("%s:%u\n", __func__, __LINE__);
        unregister_netdev(dev->pseudo_netdev);
        free_netdev(dev->pseudo_netdev);
        ib_unregister_device(&dev->ibdev);
index 01d07862ea86257330958377032283d95201498d..9190bd52f51f0186607622eac3a568ca6a10255a 100644 (file)
@@ -121,7 +121,7 @@ void c2_set_qp_state(struct c2_qp *qp, int c2_state)
        int new_state = to_ib_state(c2_state);
 
        pr_debug("%s: qp[%p] state modify %s --> %s\n",
-              __FUNCTION__,
+              __func__,
                qp,
                to_ib_state_str(qp->state),
                to_ib_state_str(new_state));
@@ -141,7 +141,7 @@ int c2_qp_modify(struct c2_dev *c2dev, struct c2_qp *qp,
        int err;
 
        pr_debug("%s:%d qp=%p, %s --> %s\n",
-               __FUNCTION__, __LINE__,
+               __func__, __LINE__,
                qp,
                to_ib_state_str(qp->state),
                to_ib_state_str(attr->qp_state));
@@ -224,7 +224,7 @@ int c2_qp_modify(struct c2_dev *c2dev, struct c2_qp *qp,
                qp->state = next_state;
 #ifdef DEBUG
        else
-               pr_debug("%s: c2_errno=%d\n", __FUNCTION__, err);
+               pr_debug("%s: c2_errno=%d\n", __func__, err);
 #endif
        /*
         * If we're going to error and generating the event here, then
@@ -243,7 +243,7 @@ int c2_qp_modify(struct c2_dev *c2dev, struct c2_qp *qp,
        vq_req_free(c2dev, vq_req);
 
        pr_debug("%s:%d qp=%p, cur_state=%s\n",
-               __FUNCTION__, __LINE__,
+               __func__, __LINE__,
                qp,
                to_ib_state_str(qp->state));
        return err;
index 7be1f87dcfa7b6153395a4e50f5d01963746ac28..7a625524e0c5a44771cc4ecc33a4c642ada54eba 100644 (file)
@@ -524,7 +524,7 @@ int __devinit c2_rnic_init(struct c2_dev *c2dev)
                goto bail1;
        }
        pci_unmap_addr_set(&c2dev->rep_vq, mapping, c2dev->rep_vq.host_dma);
-       pr_debug("%s rep_vq va %p dma %llx\n", __FUNCTION__, q1_pages,
+       pr_debug("%s rep_vq va %p dma %llx\n", __func__, q1_pages,
                 (unsigned long long) c2dev->rep_vq.host_dma);
        c2_mq_rep_init(&c2dev->rep_vq,
                   1,
@@ -545,7 +545,7 @@ int __devinit c2_rnic_init(struct c2_dev *c2dev)
                goto bail2;
        }
        pci_unmap_addr_set(&c2dev->aeq, mapping, c2dev->aeq.host_dma);
-       pr_debug("%s aeq va %p dma %llx\n", __FUNCTION__, q2_pages,
+       pr_debug("%s aeq va %p dma %llx\n", __func__, q2_pages,
                 (unsigned long long) c2dev->aeq.host_dma);
        c2_mq_rep_init(&c2dev->aeq,
                       2,
index cfdacb1ec279b15fb2f0ef43eb4789e6bd3ab654..9ce7819b7b2e5f2988d0a22fcd085cf77f5c3cad 100644 (file)
@@ -197,7 +197,7 @@ int vq_send_wr(struct c2_dev *c2dev, union c2wr *wr)
         */
        while (msg == NULL) {
                pr_debug("%s:%d no available msg in VQ, waiting...\n",
-                      __FUNCTION__, __LINE__);
+                      __func__, __LINE__);
                init_waitqueue_entry(&__wait, current);
                add_wait_queue(&c2dev->req_vq_wo, &__wait);
                spin_unlock(&c2dev->vqlock);
index 75f7b16a271d6652a9aac3326c6a56ffc18f5ffe..a8d24d53f3070466893fe47cdfc7ee7985c215a3 100644 (file)
@@ -45,16 +45,16 @@ void cxio_dump_tpt(struct cxio_rdev *rdev, u32 stag)
 
        m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
        if (!m) {
-               PDBG("%s couldn't allocate memory.\n", __FUNCTION__);
+               PDBG("%s couldn't allocate memory.\n", __func__);
                return;
        }
        m->mem_id = MEM_PMRX;
        m->addr = (stag>>8) * 32 + rdev->rnic_info.tpt_base;
        m->len = size;
-       PDBG("%s TPT addr 0x%x len %d\n", __FUNCTION__, m->addr, m->len);
+       PDBG("%s TPT addr 0x%x len %d\n", __func__, m->addr, m->len);
        rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
        if (rc) {
-               PDBG("%s toectl returned error %d\n", __FUNCTION__, rc);
+               PDBG("%s toectl returned error %d\n", __func__, rc);
                kfree(m);
                return;
        }
@@ -82,17 +82,17 @@ void cxio_dump_pbl(struct cxio_rdev *rdev, u32 pbl_addr, uint len, u8 shift)
 
        m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
        if (!m) {
-               PDBG("%s couldn't allocate memory.\n", __FUNCTION__);
+               PDBG("%s couldn't allocate memory.\n", __func__);
                return;
        }
        m->mem_id = MEM_PMRX;
        m->addr = pbl_addr;
        m->len = size;
        PDBG("%s PBL addr 0x%x len %d depth %d\n",
-               __FUNCTION__, m->addr, m->len, npages);
+               __func__, m->addr, m->len, npages);
        rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
        if (rc) {
-               PDBG("%s toectl returned error %d\n", __FUNCTION__, rc);
+               PDBG("%s toectl returned error %d\n", __func__, rc);
                kfree(m);
                return;
        }
@@ -144,16 +144,16 @@ void cxio_dump_rqt(struct cxio_rdev *rdev, u32 hwtid, int nents)
 
        m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
        if (!m) {
-               PDBG("%s couldn't allocate memory.\n", __FUNCTION__);
+               PDBG("%s couldn't allocate memory.\n", __func__);
                return;
        }
        m->mem_id = MEM_PMRX;
        m->addr = ((hwtid)<<10) + rdev->rnic_info.rqt_base;
        m->len = size;
-       PDBG("%s RQT addr 0x%x len %d\n", __FUNCTION__, m->addr, m->len);
+       PDBG("%s RQT addr 0x%x len %d\n", __func__, m->addr, m->len);
        rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
        if (rc) {
-               PDBG("%s toectl returned error %d\n", __FUNCTION__, rc);
+               PDBG("%s toectl returned error %d\n", __func__, rc);
                kfree(m);
                return;
        }
@@ -177,16 +177,16 @@ void cxio_dump_tcb(struct cxio_rdev *rdev, u32 hwtid)
 
        m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
        if (!m) {
-               PDBG("%s couldn't allocate memory.\n", __FUNCTION__);
+               PDBG("%s couldn't allocate memory.\n", __func__);
                return;
        }
        m->mem_id = MEM_CM;
        m->addr = hwtid * size;
        m->len = size;
-       PDBG("%s TCB %d len %d\n", __FUNCTION__, m->addr, m->len);
+       PDBG("%s TCB %d len %d\n", __func__, m->addr, m->len);
        rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
        if (rc) {
-               PDBG("%s toectl returned error %d\n", __FUNCTION__, rc);
+               PDBG("%s toectl returned error %d\n", __func__, rc);
                kfree(m);
                return;
        }
index 03c5ff62889a25c60b01e54afcefc44f89c503de..66eb7030aea83c1d01f89838621959d28cf191b6 100644 (file)
@@ -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;
 
                /*
index d3095ae5bc2e1fb8cc66b61149c9fe479ee2beed..45ed4f25ef785b1efa23cd6f335d8569e4c81c55 100644 (file)
@@ -206,13 +206,13 @@ void cxio_hal_put_stag(struct cxio_hal_resource *rscp, u32 stag)
 u32 cxio_hal_get_qpid(struct cxio_hal_resource *rscp)
 {
        u32 qpid = cxio_hal_get_resource(rscp->qpid_fifo);
-       PDBG("%s qpid 0x%x\n", __FUNCTION__, qpid);
+       PDBG("%s qpid 0x%x\n", __func__, qpid);
        return qpid;
 }
 
 void cxio_hal_put_qpid(struct cxio_hal_resource *rscp, u32 qpid)
 {
-       PDBG("%s qpid 0x%x\n", __FUNCTION__, qpid);
+       PDBG("%s qpid 0x%x\n", __func__, qpid);
        cxio_hal_put_resource(rscp->qpid_fifo, qpid);
 }
 
@@ -255,13 +255,13 @@ void cxio_hal_destroy_resource(struct cxio_hal_resource *rscp)
 u32 cxio_hal_pblpool_alloc(struct cxio_rdev *rdev_p, int size)
 {
        unsigned long addr = gen_pool_alloc(rdev_p->pbl_pool, size);
-       PDBG("%s addr 0x%x size %d\n", __FUNCTION__, (u32)addr, size);
+       PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size);
        return (u32)addr;
 }
 
 void cxio_hal_pblpool_free(struct cxio_rdev *rdev_p, u32 addr, int size)
 {
-       PDBG("%s addr 0x%x size %d\n", __FUNCTION__, addr, size);
+       PDBG("%s addr 0x%x size %d\n", __func__, addr, size);
        gen_pool_free(rdev_p->pbl_pool, (unsigned long)addr, size);
 }
 
@@ -292,13 +292,13 @@ void cxio_hal_pblpool_destroy(struct cxio_rdev *rdev_p)
 u32 cxio_hal_rqtpool_alloc(struct cxio_rdev *rdev_p, int size)
 {
        unsigned long addr = gen_pool_alloc(rdev_p->rqt_pool, size << 6);
-       PDBG("%s addr 0x%x size %d\n", __FUNCTION__, (u32)addr, size << 6);
+       PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size << 6);
        return (u32)addr;
 }
 
 void cxio_hal_rqtpool_free(struct cxio_rdev *rdev_p, u32 addr, int size)
 {
-       PDBG("%s addr 0x%x size %d\n", __FUNCTION__, addr, size << 6);
+       PDBG("%s addr 0x%x size %d\n", __func__, addr, size << 6);
        gen_pool_free(rdev_p->rqt_pool, (unsigned long)addr, size << 6);
 }
 
index 0315c9d9fce931c680f99107c7cfc322f7d86533..6ba4138c8ec3a8b434526e7f7ceba7f641569d62 100644 (file)
@@ -65,7 +65,7 @@ static DEFINE_MUTEX(dev_mutex);
 
 static void rnic_init(struct iwch_dev *rnicp)
 {
-       PDBG("%s iwch_dev %p\n", __FUNCTION__,  rnicp);
+       PDBG("%s iwch_dev %p\n", __func__,  rnicp);
        idr_init(&rnicp->cqidr);
        idr_init(&rnicp->qpidr);
        idr_init(&rnicp->mmidr);
@@ -106,7 +106,7 @@ static void open_rnic_dev(struct t3cdev *tdev)
        struct iwch_dev *rnicp;
        static int vers_printed;
 
-       PDBG("%s t3cdev %p\n", __FUNCTION__,  tdev);
+       PDBG("%s t3cdev %p\n", __func__,  tdev);
        if (!vers_printed++)
                printk(KERN_INFO MOD "Chelsio T3 RDMA Driver - version %s\n",
                       DRV_VERSION);
@@ -144,7 +144,7 @@ static void open_rnic_dev(struct t3cdev *tdev)
 static void close_rnic_dev(struct t3cdev *tdev)
 {
        struct iwch_dev *dev, *tmp;
-       PDBG("%s t3cdev %p\n", __FUNCTION__,  tdev);
+       PDBG("%s t3cdev %p\n", __func__,  tdev);
        mutex_lock(&dev_mutex);
        list_for_each_entry_safe(dev, tmp, &dev_list, entry) {
                if (dev->rdev.t3cdev_p == tdev) {
index 99f2f2a46bf79244270be761d4f9637aad540694..72ca360c3dbc12c2b0a36e865b5ad18601eb3bd2 100644 (file)
@@ -110,9 +110,9 @@ static void connect_reply_upcall(struct iwch_ep *ep, int status);
 
 static void start_ep_timer(struct iwch_ep *ep)
 {
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        if (timer_pending(&ep->timer)) {
-               PDBG("%s stopped / restarted timer ep %p\n", __FUNCTION__, ep);
+               PDBG("%s stopped / restarted timer ep %p\n", __func__, ep);
                del_timer_sync(&ep->timer);
        } else
                get_ep(&ep->com);
@@ -124,7 +124,7 @@ static void start_ep_timer(struct iwch_ep *ep)
 
 static void stop_ep_timer(struct iwch_ep *ep)
 {
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        del_timer_sync(&ep->timer);
        put_ep(&ep->com);
 }
@@ -190,7 +190,7 @@ int iwch_resume_tid(struct iwch_ep *ep)
 
 static void set_emss(struct iwch_ep *ep, u16 opt)
 {
-       PDBG("%s ep %p opt %u\n", __FUNCTION__, ep, opt);
+       PDBG("%s ep %p opt %u\n", __func__, ep, opt);
        ep->emss = T3C_DATA(ep->com.tdev)->mtus[G_TCPOPT_MSS(opt)] - 40;
        if (G_TCPOPT_TSTAMP(opt))
                ep->emss -= 12;
@@ -220,7 +220,7 @@ static void state_set(struct iwch_ep_common *epc, enum iwch_ep_state new)
        unsigned long flags;
 
        spin_lock_irqsave(&epc->lock, flags);
-       PDBG("%s - %s -> %s\n", __FUNCTION__, states[epc->state], states[new]);
+       PDBG("%s - %s -> %s\n", __func__, states[epc->state], states[new]);
        __state_set(epc, new);
        spin_unlock_irqrestore(&epc->lock, flags);
        return;
@@ -236,7 +236,7 @@ static void *alloc_ep(int size, gfp_t gfp)
                spin_lock_init(&epc->lock);
                init_waitqueue_head(&epc->waitq);
        }
-       PDBG("%s alloc ep %p\n", __FUNCTION__, epc);
+       PDBG("%s alloc ep %p\n", __func__, epc);
        return epc;
 }
 
@@ -244,13 +244,13 @@ void __free_ep(struct kref *kref)
 {
        struct iwch_ep_common *epc;
        epc = container_of(kref, struct iwch_ep_common, kref);
-       PDBG("%s ep %p state %s\n", __FUNCTION__, epc, states[state_read(epc)]);
+       PDBG("%s ep %p state %s\n", __func__, epc, states[state_read(epc)]);
        kfree(epc);
 }
 
 static void release_ep_resources(struct iwch_ep *ep)
 {
-       PDBG("%s ep %p tid %d\n", __FUNCTION__, ep, ep->hwtid);
+       PDBG("%s ep %p tid %d\n", __func__, ep, ep->hwtid);
        cxgb3_remove_tid(ep->com.tdev, (void *)ep, ep->hwtid);
        dst_release(ep->dst);
        l2t_release(L2DATA(ep->com.tdev), ep->l2t);
@@ -349,7 +349,7 @@ static unsigned int find_best_mtu(const struct t3c_data *d, unsigned short mtu)
 
 static void arp_failure_discard(struct t3cdev *dev, struct sk_buff *skb)
 {
-       PDBG("%s t3cdev %p\n", __FUNCTION__, dev);
+       PDBG("%s t3cdev %p\n", __func__, dev);
        kfree_skb(skb);
 }
 
@@ -370,7 +370,7 @@ static void abort_arp_failure(struct t3cdev *dev, struct sk_buff *skb)
 {
        struct cpl_abort_req *req = cplhdr(skb);
 
-       PDBG("%s t3cdev %p\n", __FUNCTION__, dev);
+       PDBG("%s t3cdev %p\n", __func__, dev);
        req->cmd = CPL_ABORT_NO_RST;
        cxgb3_ofld_send(dev, skb);
 }
@@ -380,10 +380,10 @@ static int send_halfclose(struct iwch_ep *ep, gfp_t gfp)
        struct cpl_close_con_req *req;
        struct sk_buff *skb;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        skb = get_skb(NULL, sizeof(*req), gfp);
        if (!skb) {
-               printk(KERN_ERR MOD "%s - failed to alloc skb\n", __FUNCTION__);
+               printk(KERN_ERR MOD "%s - failed to alloc skb\n", __func__);
                return -ENOMEM;
        }
        skb->priority = CPL_PRIORITY_DATA;
@@ -400,11 +400,11 @@ static int send_abort(struct iwch_ep *ep, struct sk_buff *skb, gfp_t gfp)
 {
        struct cpl_abort_req *req;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        skb = get_skb(skb, sizeof(*req), gfp);
        if (!skb) {
                printk(KERN_ERR MOD "%s - failed to alloc skb.\n",
-                      __FUNCTION__);
+                      __func__);
                return -ENOMEM;
        }
        skb->priority = CPL_PRIORITY_DATA;
@@ -426,12 +426,12 @@ static int send_connect(struct iwch_ep *ep)
        unsigned int mtu_idx;
        int wscale;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
 
        skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
        if (!skb) {
                printk(KERN_ERR MOD "%s - failed to alloc skb.\n",
-                      __FUNCTION__);
+                      __func__);
                return -ENOMEM;
        }
        mtu_idx = find_best_mtu(T3C_DATA(ep->com.tdev), dst_mtu(ep->dst));
@@ -470,7 +470,7 @@ static void send_mpa_req(struct iwch_ep *ep, struct sk_buff *skb)
        struct mpa_message *mpa;
        int len;
 
-       PDBG("%s ep %p pd_len %d\n", __FUNCTION__, ep, ep->plen);
+       PDBG("%s ep %p pd_len %d\n", __func__, ep, ep->plen);
 
        BUG_ON(skb_cloned(skb));
 
@@ -530,13 +530,13 @@ static int send_mpa_reject(struct iwch_ep *ep, const void *pdata, u8 plen)
        struct mpa_message *mpa;
        struct sk_buff *skb;
 
-       PDBG("%s ep %p plen %d\n", __FUNCTION__, ep, plen);
+       PDBG("%s ep %p plen %d\n", __func__, ep, plen);
 
        mpalen = sizeof(*mpa) + plen;
 
        skb = get_skb(NULL, mpalen + sizeof(*req), GFP_KERNEL);
        if (!skb) {
-               printk(KERN_ERR MOD "%s - cannot alloc skb!\n", __FUNCTION__);
+               printk(KERN_ERR MOD "%s - cannot alloc skb!\n", __func__);
                return -ENOMEM;
        }
        skb_reserve(skb, sizeof(*req));
@@ -580,13 +580,13 @@ static int send_mpa_reply(struct iwch_ep *ep, const void *pdata, u8 plen)
        int len;
        struct sk_buff *skb;
 
-       PDBG("%s ep %p plen %d\n", __FUNCTION__, ep, plen);
+       PDBG("%s ep %p plen %d\n", __func__, ep, plen);
 
        mpalen = sizeof(*mpa) + plen;
 
        skb = get_skb(NULL, mpalen + sizeof(*req), GFP_KERNEL);
        if (!skb) {
-               printk(KERN_ERR MOD "%s - cannot alloc skb!\n", __FUNCTION__);
+               printk(KERN_ERR MOD "%s - cannot alloc skb!\n", __func__);
                return -ENOMEM;
        }
        skb->priority = CPL_PRIORITY_DATA;
@@ -630,7 +630,7 @@ static int act_establish(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        struct cpl_act_establish *req = cplhdr(skb);
        unsigned int tid = GET_TID(req);
 
-       PDBG("%s ep %p tid %d\n", __FUNCTION__, ep, tid);
+       PDBG("%s ep %p tid %d\n", __func__, ep, tid);
 
        dst_confirm(ep->dst);
 
@@ -663,7 +663,7 @@ static void close_complete_upcall(struct iwch_ep *ep)
 {
        struct iw_cm_event event;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        memset(&event, 0, sizeof(event));
        event.event = IW_CM_EVENT_CLOSE;
        if (ep->com.cm_id) {
@@ -680,7 +680,7 @@ static void peer_close_upcall(struct iwch_ep *ep)
 {
        struct iw_cm_event event;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        memset(&event, 0, sizeof(event));
        event.event = IW_CM_EVENT_DISCONNECT;
        if (ep->com.cm_id) {
@@ -694,7 +694,7 @@ static void peer_abort_upcall(struct iwch_ep *ep)
 {
        struct iw_cm_event event;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        memset(&event, 0, sizeof(event));
        event.event = IW_CM_EVENT_CLOSE;
        event.status = -ECONNRESET;
@@ -712,7 +712,7 @@ static void connect_reply_upcall(struct iwch_ep *ep, int status)
 {
        struct iw_cm_event event;
 
-       PDBG("%s ep %p status %d\n", __FUNCTION__, ep, status);
+       PDBG("%s ep %p status %d\n", __func__, ep, status);
        memset(&event, 0, sizeof(event));
        event.event = IW_CM_EVENT_CONNECT_REPLY;
        event.status = status;
@@ -724,7 +724,7 @@ static void connect_reply_upcall(struct iwch_ep *ep, int status)
                event.private_data = ep->mpa_pkt + sizeof(struct mpa_message);
        }
        if (ep->com.cm_id) {
-               PDBG("%s ep %p tid %d status %d\n", __FUNCTION__, ep,
+               PDBG("%s ep %p tid %d status %d\n", __func__, ep,
                     ep->hwtid, status);
                ep->com.cm_id->event_handler(ep->com.cm_id, &event);
        }
@@ -739,7 +739,7 @@ static void connect_request_upcall(struct iwch_ep *ep)
 {
        struct iw_cm_event event;
 
-       PDBG("%s ep %p tid %d\n", __FUNCTION__, ep, ep->hwtid);
+       PDBG("%s ep %p tid %d\n", __func__, ep, ep->hwtid);
        memset(&event, 0, sizeof(event));
        event.event = IW_CM_EVENT_CONNECT_REQUEST;
        event.local_addr = ep->com.local_addr;
@@ -759,11 +759,11 @@ static void established_upcall(struct iwch_ep *ep)
 {
        struct iw_cm_event event;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        memset(&event, 0, sizeof(event));
        event.event = IW_CM_EVENT_ESTABLISHED;
        if (ep->com.cm_id) {
-               PDBG("%s ep %p tid %d\n", __FUNCTION__, ep, ep->hwtid);
+               PDBG("%s ep %p tid %d\n", __func__, ep, ep->hwtid);
                ep->com.cm_id->event_handler(ep->com.cm_id, &event);
        }
 }
@@ -773,7 +773,7 @@ static int update_rx_credits(struct iwch_ep *ep, u32 credits)
        struct cpl_rx_data_ack *req;
        struct sk_buff *skb;
 
-       PDBG("%s ep %p credits %u\n", __FUNCTION__, ep, credits);
+       PDBG("%s ep %p credits %u\n", __func__, ep, credits);
        skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
        if (!skb) {
                printk(KERN_ERR MOD "update_rx_credits - cannot alloc skb!\n");
@@ -797,7 +797,7 @@ static void process_mpa_reply(struct iwch_ep *ep, struct sk_buff *skb)
        enum iwch_qp_attr_mask mask;
        int err;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
 
        /*
         * Stop mpa timer.  If it expired, then the state has
@@ -884,7 +884,7 @@ static void process_mpa_reply(struct iwch_ep *ep, struct sk_buff *skb)
        ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
        ep->mpa_attr.version = mpa_rev;
        PDBG("%s - crc_enabled=%d, recv_marker_enabled=%d, "
-            "xmit_marker_enabled=%d, version=%d\n", __FUNCTION__,
+            "xmit_marker_enabled=%d, version=%d\n", __func__,
             ep->mpa_attr.crc_enabled, ep->mpa_attr.recv_marker_enabled,
             ep->mpa_attr.xmit_marker_enabled, ep->mpa_attr.version);
 
@@ -915,7 +915,7 @@ static void process_mpa_request(struct iwch_ep *ep, struct sk_buff *skb)
        struct mpa_message *mpa;
        u16 plen;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
 
        /*
         * Stop mpa timer.  If it expired, then the state has
@@ -935,7 +935,7 @@ static void process_mpa_request(struct iwch_ep *ep, struct sk_buff *skb)
                return;
        }
 
-       PDBG("%s enter (%s line %u)\n", __FUNCTION__, __FILE__, __LINE__);
+       PDBG("%s enter (%s line %u)\n", __func__, __FILE__, __LINE__);
 
        /*
         * Copy the new data into our accumulation buffer.
@@ -950,7 +950,7 @@ static void process_mpa_request(struct iwch_ep *ep, struct sk_buff *skb)
         */
        if (ep->mpa_pkt_len < sizeof(*mpa))
                return;
-       PDBG("%s enter (%s line %u)\n", __FUNCTION__, __FILE__, __LINE__);
+       PDBG("%s enter (%s line %u)\n", __func__, __FILE__, __LINE__);
        mpa = (struct mpa_message *) ep->mpa_pkt;
 
        /*
@@ -1000,7 +1000,7 @@ static void process_mpa_request(struct iwch_ep *ep, struct sk_buff *skb)
        ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
        ep->mpa_attr.version = mpa_rev;
        PDBG("%s - crc_enabled=%d, recv_marker_enabled=%d, "
-            "xmit_marker_enabled=%d, version=%d\n", __FUNCTION__,
+            "xmit_marker_enabled=%d, version=%d\n", __func__,
             ep->mpa_attr.crc_enabled, ep->mpa_attr.recv_marker_enabled,
             ep->mpa_attr.xmit_marker_enabled, ep->mpa_attr.version);
 
@@ -1017,7 +1017,7 @@ static int rx_data(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        struct cpl_rx_data *hdr = cplhdr(skb);
        unsigned int dlen = ntohs(hdr->len);
 
-       PDBG("%s ep %p dlen %u\n", __FUNCTION__, ep, dlen);
+       PDBG("%s ep %p dlen %u\n", __func__, ep, dlen);
 
        skb_pull(skb, sizeof(*hdr));
        skb_trim(skb, dlen);
@@ -1037,7 +1037,7 @@ static int rx_data(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        default:
                printk(KERN_ERR MOD "%s Unexpected streaming data."
                       " ep %p state %d tid %d\n",
-                      __FUNCTION__, ep, state_read(&ep->com), ep->hwtid);
+                      __func__, ep, state_read(&ep->com), ep->hwtid);
 
                /*
                 * The ep will timeout and inform the ULP of the failure.
@@ -1063,7 +1063,7 @@ static int tx_ack(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        struct cpl_wr_ack *hdr = cplhdr(skb);
        unsigned int credits = ntohs(hdr->credits);
 
-       PDBG("%s ep %p credits %u\n", __FUNCTION__, ep, credits);
+       PDBG("%s ep %p credits %u\n", __func__, ep, credits);
 
        if (credits == 0)
                return CPL_RET_BUF_DONE;
@@ -1084,7 +1084,7 @@ static int abort_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
 {
        struct iwch_ep *ep = ctx;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
 
        /*
         * We get 2 abort replies from the HW.  The first one must
@@ -1115,7 +1115,7 @@ static int act_open_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        struct iwch_ep *ep = ctx;
        struct cpl_act_open_rpl *rpl = cplhdr(skb);
 
-       PDBG("%s ep %p status %u errno %d\n", __FUNCTION__, ep, rpl->status,
+       PDBG("%s ep %p status %u errno %d\n", __func__, ep, rpl->status,
             status2errno(rpl->status));
        connect_reply_upcall(ep, status2errno(rpl->status));
        state_set(&ep->com, DEAD);
@@ -1133,7 +1133,7 @@ static int listen_start(struct iwch_listen_ep *ep)
        struct sk_buff *skb;
        struct cpl_pass_open_req *req;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
        if (!skb) {
                printk(KERN_ERR MOD "t3c_listen_start failed to alloc skb!\n");
@@ -1162,7 +1162,7 @@ static int pass_open_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        struct iwch_listen_ep *ep = ctx;
        struct cpl_pass_open_rpl *rpl = cplhdr(skb);
 
-       PDBG("%s ep %p status %d error %d\n", __FUNCTION__, ep,
+       PDBG("%s ep %p status %d error %d\n", __func__, ep,
             rpl->status, status2errno(rpl->status));
        ep->com.rpl_err = status2errno(rpl->status);
        ep->com.rpl_done = 1;
@@ -1176,10 +1176,10 @@ static int listen_stop(struct iwch_listen_ep *ep)
        struct sk_buff *skb;
        struct cpl_close_listserv_req *req;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
        if (!skb) {
-               printk(KERN_ERR MOD "%s - failed to alloc skb\n", __FUNCTION__);
+               printk(KERN_ERR MOD "%s - failed to alloc skb\n", __func__);
                return -ENOMEM;
        }
        req = (struct cpl_close_listserv_req *) skb_put(skb, sizeof(*req));
@@ -1197,7 +1197,7 @@ static int close_listsrv_rpl(struct t3cdev *tdev, struct sk_buff *skb,
        struct iwch_listen_ep *ep = ctx;
        struct cpl_close_listserv_rpl *rpl = cplhdr(skb);
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        ep->com.rpl_err = status2errno(rpl->status);
        ep->com.rpl_done = 1;
        wake_up(&ep->com.waitq);
@@ -1211,7 +1211,7 @@ static void accept_cr(struct iwch_ep *ep, __be32 peer_ip, struct sk_buff *skb)
        u32 opt0h, opt0l, opt2;
        int wscale;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        BUG_ON(skb_cloned(skb));
        skb_trim(skb, sizeof(*rpl));
        skb_get(skb);
@@ -1244,7 +1244,7 @@ static void accept_cr(struct iwch_ep *ep, __be32 peer_ip, struct sk_buff *skb)
 static void reject_cr(struct t3cdev *tdev, u32 hwtid, __be32 peer_ip,
                      struct sk_buff *skb)
 {
-       PDBG("%s t3cdev %p tid %u peer_ip %x\n", __FUNCTION__, tdev, hwtid,
+       PDBG("%s t3cdev %p tid %u peer_ip %x\n", __func__, tdev, hwtid,
             peer_ip);
        BUG_ON(skb_cloned(skb));
        skb_trim(skb, sizeof(struct cpl_tid_release));
@@ -1279,11 +1279,11 @@ static int pass_accept_req(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        struct rtable *rt;
        struct iff_mac tim;
 
-       PDBG("%s parent ep %p tid %u\n", __FUNCTION__, parent_ep, hwtid);
+       PDBG("%s parent ep %p tid %u\n", __func__, parent_ep, hwtid);
 
        if (state_read(&parent_ep->com) != LISTEN) {
                printk(KERN_ERR "%s - listening ep not in LISTEN\n",
-                      __FUNCTION__);
+                      __func__);
                goto reject;
        }
 
@@ -1295,7 +1295,7 @@ static int pass_accept_req(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        if (tdev->ctl(tdev, GET_IFF_FROM_MAC, &tim) < 0 || !tim.dev) {
                printk(KERN_ERR
                        "%s bad dst mac %02x %02x %02x %02x %02x %02x\n",
-                       __FUNCTION__,
+                       __func__,
                        req->dst_mac[0],
                        req->dst_mac[1],
                        req->dst_mac[2],
@@ -1313,21 +1313,21 @@ static int pass_accept_req(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
                        req->peer_port, G_PASS_OPEN_TOS(ntohl(req->tos_tid)));
        if (!rt) {
                printk(KERN_ERR MOD "%s - failed to find dst entry!\n",
-                      __FUNCTION__);
+                      __func__);
                goto reject;
        }
        dst = &rt->u.dst;
        l2t = t3_l2t_get(tdev, dst->neighbour, dst->neighbour->dev);
        if (!l2t) {
                printk(KERN_ERR MOD "%s - failed to allocate l2t entry!\n",
-                      __FUNCTION__);
+                      __func__);
                dst_release(dst);
                goto reject;
        }
        child_ep = alloc_ep(sizeof(*child_ep), GFP_KERNEL);
        if (!child_ep) {
                printk(KERN_ERR MOD "%s - failed to allocate ep entry!\n",
-                      __FUNCTION__);
+                      __func__);
                l2t_release(L2DATA(tdev), l2t);
                dst_release(dst);
                goto reject;
@@ -1362,7 +1362,7 @@ static int pass_establish(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        struct iwch_ep *ep = ctx;
        struct cpl_pass_establish *req = cplhdr(skb);
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        ep->snd_seq = ntohl(req->snd_isn);
        ep->rcv_seq = ntohl(req->rcv_isn);
 
@@ -1383,7 +1383,7 @@ static int peer_close(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        int disconnect = 1;
        int release = 0;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        dst_confirm(ep->dst);
 
        spin_lock_irqsave(&ep->com.lock, flags);
@@ -1473,7 +1473,7 @@ static int peer_abort(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        int state;
 
        if (is_neg_adv_abort(req->status)) {
-               PDBG("%s neg_adv_abort ep %p tid %d\n", __FUNCTION__, ep,
+               PDBG("%s neg_adv_abort ep %p tid %d\n", __func__, ep,
                     ep->hwtid);
                t3_l2t_send_event(ep->com.tdev, ep->l2t);
                return CPL_RET_BUF_DONE;
@@ -1489,7 +1489,7 @@ static int peer_abort(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        }
 
        state = state_read(&ep->com);
-       PDBG("%s ep %p state %u\n", __FUNCTION__, ep, state);
+       PDBG("%s ep %p state %u\n", __func__, ep, state);
        switch (state) {
        case CONNECTING:
                break;
@@ -1528,14 +1528,14 @@ static int peer_abort(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
                        if (ret)
                                printk(KERN_ERR MOD
                                       "%s - qp <- error failed!\n",
-                                      __FUNCTION__);
+                                      __func__);
                }
                peer_abort_upcall(ep);
                break;
        case ABORTING:
                break;
        case DEAD:
-               PDBG("%s PEER_ABORT IN DEAD STATE!!!!\n", __FUNCTION__);
+               PDBG("%s PEER_ABORT IN DEAD STATE!!!!\n", __func__);
                return CPL_RET_BUF_DONE;
        default:
                BUG_ON(1);
@@ -1546,7 +1546,7 @@ static int peer_abort(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        rpl_skb = get_skb(skb, sizeof(*rpl), GFP_KERNEL);
        if (!rpl_skb) {
                printk(KERN_ERR MOD "%s - cannot allocate skb!\n",
-                      __FUNCTION__);
+                      __func__);
                dst_release(ep->dst);
                l2t_release(L2DATA(ep->com.tdev), ep->l2t);
                put_ep(&ep->com);
@@ -1573,7 +1573,7 @@ static int close_con_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        unsigned long flags;
        int release = 0;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        BUG_ON(!ep);
 
        /* The cm_id may be null if we failed to connect */
@@ -1624,9 +1624,9 @@ static int terminate(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
 {
        struct iwch_ep *ep = ctx;
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        skb_pull(skb, sizeof(struct cpl_rdma_terminate));
-       PDBG("%s saving %d bytes of term msg\n", __FUNCTION__, skb->len);
+       PDBG("%s saving %d bytes of term msg\n", __func__, skb->len);
        skb_copy_from_linear_data(skb, ep->com.qp->attr.terminate_buffer,
                                  skb->len);
        ep->com.qp->attr.terminate_msg_len = skb->len;
@@ -1639,13 +1639,13 @@ static int ec_status(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
        struct cpl_rdma_ec_status *rep = cplhdr(skb);
        struct iwch_ep *ep = ctx;
 
-       PDBG("%s ep %p tid %u status %d\n", __FUNCTION__, ep, ep->hwtid,
+       PDBG("%s ep %p tid %u status %d\n", __func__, ep, ep->hwtid,
             rep->status);
        if (rep->status) {
                struct iwch_qp_attributes attrs;
 
                printk(KERN_ERR MOD "%s BAD CLOSE - Aborting tid %u\n",
-                      __FUNCTION__, ep->hwtid);
+                      __func__, ep->hwtid);
                stop_ep_timer(ep);
                attrs.next_state = IWCH_QP_STATE_ERROR;
                iwch_modify_qp(ep->com.qp->rhp,
@@ -1663,7 +1663,7 @@ static void ep_timeout(unsigned long arg)
        unsigned long flags;
 
        spin_lock_irqsave(&ep->com.lock, flags);
-       PDBG("%s ep %p tid %u state %d\n", __FUNCTION__, ep, ep->hwtid,
+       PDBG("%s ep %p tid %u state %d\n", __func__, ep, ep->hwtid,
             ep->com.state);
        switch (ep->com.state) {
        case MPA_REQ_SENT:
@@ -1693,7 +1693,7 @@ int iwch_reject_cr(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
 {
        int err;
        struct iwch_ep *ep = to_ep(cm_id);
-       PDBG("%s ep %p tid %u\n", __FUNCTION__, ep, ep->hwtid);
+       PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
 
        if (state_read(&ep->com) == DEAD) {
                put_ep(&ep->com);
@@ -1718,7 +1718,7 @@ int iwch_accept_cr(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
        struct iwch_dev *h = to_iwch_dev(cm_id->device);
        struct iwch_qp *qp = get_qhp(h, conn_param->qpn);
 
-       PDBG("%s ep %p tid %u\n", __FUNCTION__, ep, ep->hwtid);
+       PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
        if (state_read(&ep->com) == DEAD)
                return -ECONNRESET;
 
@@ -1739,7 +1739,7 @@ int iwch_accept_cr(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
        ep->com.rpl_err = 0;
        ep->ird = conn_param->ird;
        ep->ord = conn_param->ord;
-       PDBG("%s %d ird %d ord %d\n", __FUNCTION__, __LINE__, ep->ird, ep->ord);
+       PDBG("%s %d ird %d ord %d\n", __func__, __LINE__, ep->ird, ep->ord);
 
        get_ep(&ep->com);
 
@@ -1810,7 +1810,7 @@ int iwch_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
 
        ep = alloc_ep(sizeof(*ep), GFP_KERNEL);
        if (!ep) {
-               printk(KERN_ERR MOD "%s - cannot alloc ep.\n", __FUNCTION__);
+               printk(KERN_ERR MOD "%s - cannot alloc ep.\n", __func__);
                err = -ENOMEM;
                goto out;
        }
@@ -1827,7 +1827,7 @@ int iwch_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
        ep->com.cm_id = cm_id;
        ep->com.qp = get_qhp(h, conn_param->qpn);
        BUG_ON(!ep->com.qp);
-       PDBG("%s qpn 0x%x qp %p cm_id %p\n", __FUNCTION__, conn_param->qpn,
+       PDBG("%s qpn 0x%x qp %p cm_id %p\n", __func__, conn_param->qpn,
             ep->com.qp, cm_id);
 
        /*
@@ -1835,7 +1835,7 @@ int iwch_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         */
        ep->atid = cxgb3_alloc_atid(h->rdev.t3cdev_p, &t3c_client, ep);
        if (ep->atid == -1) {
-               printk(KERN_ERR MOD "%s - cannot alloc atid.\n", __FUNCTION__);
+               printk(KERN_ERR MOD "%s - cannot alloc atid.\n", __func__);
                err = -ENOMEM;
                goto fail2;
        }
@@ -1847,7 +1847,7 @@ int iwch_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                        cm_id->local_addr.sin_port,
                        cm_id->remote_addr.sin_port, IPTOS_LOWDELAY);
        if (!rt) {
-               printk(KERN_ERR MOD "%s - cannot find route.\n", __FUNCTION__);
+               printk(KERN_ERR MOD "%s - cannot find route.\n", __func__);
                err = -EHOSTUNREACH;
                goto fail3;
        }
@@ -1857,7 +1857,7 @@ int iwch_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
        ep->l2t = t3_l2t_get(ep->com.tdev, ep->dst->neighbour,
                             ep->dst->neighbour->dev);
        if (!ep->l2t) {
-               printk(KERN_ERR MOD "%s - cannot alloc l2e.\n", __FUNCTION__);
+               printk(KERN_ERR MOD "%s - cannot alloc l2e.\n", __func__);
                err = -ENOMEM;
                goto fail4;
        }
@@ -1894,11 +1894,11 @@ int iwch_create_listen(struct iw_cm_id *cm_id, int backlog)
 
        ep = alloc_ep(sizeof(*ep), GFP_KERNEL);
        if (!ep) {
-               printk(KERN_ERR MOD "%s - cannot alloc ep.\n", __FUNCTION__);
+               printk(KERN_ERR MOD "%s - cannot alloc ep.\n", __func__);
                err = -ENOMEM;
                goto fail1;
        }
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
        ep->com.tdev = h->rdev.t3cdev_p;
        cm_id->add_ref(cm_id);
        ep->com.cm_id = cm_id;
@@ -1910,7 +1910,7 @@ int iwch_create_listen(struct iw_cm_id *cm_id, int backlog)
         */
        ep->stid = cxgb3_alloc_stid(h->rdev.t3cdev_p, &t3c_client, ep);
        if (ep->stid == -1) {
-               printk(KERN_ERR MOD "%s - cannot alloc atid.\n", __FUNCTION__);
+               printk(KERN_ERR MOD "%s - cannot alloc atid.\n", __func__);
                err = -ENOMEM;
                goto fail2;
        }
@@ -1942,7 +1942,7 @@ int iwch_destroy_listen(struct iw_cm_id *cm_id)
        int err;
        struct iwch_listen_ep *ep = to_listen_ep(cm_id);
 
-       PDBG("%s ep %p\n", __FUNCTION__, ep);
+       PDBG("%s ep %p\n", __func__, ep);
 
        might_sleep();
        state_set(&ep->com, DEAD);
@@ -1965,11 +1965,11 @@ int iwch_ep_disconnect(struct iwch_ep *ep, int abrupt, gfp_t gfp)
 
        spin_lock_irqsave(&ep->com.lock, flags);
 
-       PDBG("%s ep %p state %s, abrupt %d\n", __FUNCTION__, ep,
+       PDBG("%s ep %p state %s, abrupt %d\n", __func__, ep,
             states[ep->com.state], abrupt);
 
        if (ep->com.state == DEAD) {
-               PDBG("%s already dead ep %p\n", __FUNCTION__, ep);
+               PDBG("%s already dead ep %p\n", __func__, ep);
                goto out;
        }
 
@@ -2020,7 +2020,7 @@ int iwch_ep_redirect(void *ctx, struct dst_entry *old, struct dst_entry *new,
        if (ep->dst != old)
                return 0;
 
-       PDBG("%s ep %p redirect to dst %p l2t %p\n", __FUNCTION__, ep, new,
+       PDBG("%s ep %p redirect to dst %p l2t %p\n", __func__, ep, new,
             l2t);
        dst_hold(new);
        l2t_release(L2DATA(ep->com.tdev), ep->l2t);
index 6107e7cd9b57dd54377c29601a473bbd8f24cc12..2bb7fbdb3ff44e3136a7e2c0d7edcec9b97e842f 100644 (file)
 #define MPA_FLAGS_MASK         0xE0
 
 #define put_ep(ep) { \
-       PDBG("put_ep (via %s:%u) ep %p refcnt %d\n", __FUNCTION__, __LINE__,  \
+       PDBG("put_ep (via %s:%u) ep %p refcnt %d\n", __func__, __LINE__,  \
             ep, atomic_read(&((ep)->kref.refcount))); \
        kref_put(&((ep)->kref), __free_ep); \
 }
 
 #define get_ep(ep) { \
-       PDBG("get_ep (via %s:%u) ep %p, refcnt %d\n", __FUNCTION__, __LINE__, \
+       PDBG("get_ep (via %s:%u) ep %p, refcnt %d\n", __func__, __LINE__, \
             ep, atomic_read(&((ep)->kref.refcount))); \
        kref_get(&((ep)->kref));  \
 }
index d7624c170ee73e16a13ef7c35c0366d37faa473a..4ee8ccd0a9e52f65f62b20627226fccfac80e0f4 100644 (file)
@@ -67,7 +67,7 @@ static int iwch_poll_cq_one(struct iwch_dev *rhp, struct iwch_cq *chp,
        ret = cxio_poll_cq(wq, &(chp->cq), &cqe, &cqe_flushed, &cookie,
                                   &credit);
        if (t3a_device(chp->rhp) && credit) {
-               PDBG("%s updating %d cq credits on id %d\n", __FUNCTION__,
+               PDBG("%s updating %d cq credits on id %d\n", __func__,
                     credit, chp->cq.cqid);
                cxio_hal_cq_op(&rhp->rdev, &chp->cq, CQ_CREDIT_UPDATE, credit);
        }
@@ -83,7 +83,7 @@ static int iwch_poll_cq_one(struct iwch_dev *rhp, struct iwch_cq *chp,
        wc->vendor_err = CQE_STATUS(cqe);
 
        PDBG("%s qpid 0x%x type %d opcode %d status 0x%x wrid hi 0x%x "
-            "lo 0x%x cookie 0x%llx\n", __FUNCTION__,
+            "lo 0x%x cookie 0x%llx\n", __func__,
             CQE_QPID(cqe), CQE_TYPE(cqe),
             CQE_OPCODE(cqe), CQE_STATUS(cqe), CQE_WRID_HI(cqe),
             CQE_WRID_LOW(cqe), (unsigned long long) cookie);
index b40676662a8a88df1f46d21bac5c797475741cad..7b67a67717209424dc9493a1c27cd18861b833d3 100644 (file)
@@ -52,7 +52,7 @@ static void post_qp_event(struct iwch_dev *rnicp, struct iwch_cq *chp,
 
        if (!qhp) {
                printk(KERN_ERR "%s unaffiliated error 0x%x qpid 0x%x\n",
-                      __FUNCTION__, CQE_STATUS(rsp_msg->cqe),
+                      __func__, CQE_STATUS(rsp_msg->cqe),
                       CQE_QPID(rsp_msg->cqe));
                spin_unlock(&rnicp->lock);
                return;
@@ -61,14 +61,14 @@ static void post_qp_event(struct iwch_dev *rnicp, struct iwch_cq *chp,
        if ((qhp->attr.state == IWCH_QP_STATE_ERROR) ||
            (qhp->attr.state == IWCH_QP_STATE_TERMINATE)) {
                PDBG("%s AE received after RTS - "
-                    "qp state %d qpid 0x%x status 0x%x\n", __FUNCTION__,
+                    "qp state %d qpid 0x%x status 0x%x\n", __func__,
                     qhp->attr.state, qhp->wq.qpid, CQE_STATUS(rsp_msg->cqe));
                spin_unlock(&rnicp->lock);
                return;
        }
 
        printk(KERN_ERR "%s - AE qpid 0x%x opcode %d status 0x%x "
-              "type %d wrid.hi 0x%x wrid.lo 0x%x \n", __FUNCTION__,
+              "type %d wrid.hi 0x%x wrid.lo 0x%x \n", __func__,
               CQE_QPID(rsp_msg->cqe), CQE_OPCODE(rsp_msg->cqe),
               CQE_STATUS(rsp_msg->cqe), CQE_TYPE(rsp_msg->cqe),
               CQE_WRID_HI(rsp_msg->cqe), CQE_WRID_LOW(rsp_msg->cqe));
@@ -132,10 +132,10 @@ void iwch_ev_dispatch(struct cxio_rdev *rdev_p, struct sk_buff *skb)
            (CQE_STATUS(rsp_msg->cqe) == 0)) {
                if (SQ_TYPE(rsp_msg->cqe)) {
                        PDBG("%s QPID 0x%x ep %p disconnecting\n",
-                            __FUNCTION__, qhp->wq.qpid, qhp->ep);
+                            __func__, qhp->wq.qpid, qhp->ep);
                        iwch_ep_disconnect(qhp->ep, 0, GFP_ATOMIC);
                } else {
-                       PDBG("%s post REQ_ERR AE QPID 0x%x\n", __FUNCTION__,
+                       PDBG("%s post REQ_ERR AE QPID 0x%x\n", __func__,
                             qhp->wq.qpid);
                        post_qp_event(rnicp, chp, rsp_msg,
                                      IB_EVENT_QP_REQ_ERR, 0);
@@ -180,7 +180,7 @@ void iwch_ev_dispatch(struct cxio_rdev *rdev_p, struct sk_buff *skb)
        case TPT_ERR_INVALIDATE_SHARED_MR:
        case TPT_ERR_INVALIDATE_MR_WITH_MW_BOUND:
                printk(KERN_ERR "%s - CQE Err qpid 0x%x opcode %d status 0x%x "
-                      "type %d wrid.hi 0x%x wrid.lo 0x%x \n", __FUNCTION__,
+                      "type %d wrid.hi 0x%x wrid.lo 0x%x \n", __func__,
                       CQE_QPID(rsp_msg->cqe), CQE_OPCODE(rsp_msg->cqe),
                       CQE_STATUS(rsp_msg->cqe), CQE_TYPE(rsp_msg->cqe),
                       CQE_WRID_HI(rsp_msg->cqe), CQE_WRID_LOW(rsp_msg->cqe));
index b8797c66676d6837b265f816e55d923d450047be..58c3d61bcd14a24ec0623b0cec8d8eb6771bbaa9 100644 (file)
@@ -62,7 +62,7 @@ int iwch_register_mem(struct iwch_dev *rhp, struct iwch_pd *php,
        mmid = stag >> 8;
        mhp->ibmr.rkey = mhp->ibmr.lkey = stag;
        insert_handle(rhp, &rhp->mmidr, mhp, mmid);
-       PDBG("%s mmid 0x%x mhp %p\n", __FUNCTION__, mmid, mhp);
+       PDBG("%s mmid 0x%x mhp %p\n", __func__, mmid, mhp);
        return 0;
 }
 
@@ -96,7 +96,7 @@ int iwch_reregister_mem(struct iwch_dev *rhp, struct iwch_pd *php,
        mmid = stag >> 8;
        mhp->ibmr.rkey = mhp->ibmr.lkey = stag;
        insert_handle(rhp, &rhp->mmidr, mhp, mmid);
-       PDBG("%s mmid 0x%x mhp %p\n", __FUNCTION__, mmid, mhp);
+       PDBG("%s mmid 0x%x mhp %p\n", __func__, mmid, mhp);
        return 0;
 }
 
@@ -163,7 +163,7 @@ int build_phys_page_list(struct ib_phys_buf *buffer_list,
                            ((u64) j << *shift));
 
        PDBG("%s va 0x%llx mask 0x%llx shift %d len %lld pbl_size %d\n",
-            __FUNCTION__, (unsigned long long) *iova_start,
+            __func__, (unsigned long long) *iova_start,
             (unsigned long long) mask, *shift, (unsigned long long) *total_size,
             *npages);
 
index b2ea9210467f264cf574f74e6a44861e82dd0407..50e1f2a16e0c44bf975fec6a2e2f1d4b295ff057 100644 (file)
@@ -101,7 +101,7 @@ static int iwch_dealloc_ucontext(struct ib_ucontext *context)
        struct iwch_ucontext *ucontext = to_iwch_ucontext(context);
        struct iwch_mm_entry *mm, *tmp;
 
-       PDBG("%s context %p\n", __FUNCTION__, context);
+       PDBG("%s context %p\n", __func__, context);
        list_for_each_entry_safe(mm, tmp, &ucontext->mmaps, entry)
                kfree(mm);
        cxio_release_ucontext(&rhp->rdev, &ucontext->uctx);
@@ -115,7 +115,7 @@ static struct ib_ucontext *iwch_alloc_ucontext(struct ib_device *ibdev,
        struct iwch_ucontext *context;
        struct iwch_dev *rhp = to_iwch_dev(ibdev);
 
-       PDBG("%s ibdev %p\n", __FUNCTION__, ibdev);
+       PDBG("%s ibdev %p\n", __func__, ibdev);
        context = kzalloc(sizeof(*context), GFP_KERNEL);
        if (!context)
                return ERR_PTR(-ENOMEM);
@@ -129,7 +129,7 @@ static int iwch_destroy_cq(struct ib_cq *ib_cq)
 {
        struct iwch_cq *chp;
 
-       PDBG("%s ib_cq %p\n", __FUNCTION__, ib_cq);
+       PDBG("%s ib_cq %p\n", __func__, ib_cq);
        chp = to_iwch_cq(ib_cq);
 
        remove_handle(chp->rhp, &chp->rhp->cqidr, chp->cq.cqid);
@@ -151,7 +151,7 @@ static struct ib_cq *iwch_create_cq(struct ib_device *ibdev, int entries, int ve
        struct iwch_create_cq_req ureq;
        struct iwch_ucontext *ucontext = NULL;
 
-       PDBG("%s ib_dev %p entries %d\n", __FUNCTION__, ibdev, entries);
+       PDBG("%s ib_dev %p entries %d\n", __func__, ibdev, entries);
        rhp = to_iwch_dev(ibdev);
        chp = kzalloc(sizeof(*chp), GFP_KERNEL);
        if (!chp)
@@ -233,7 +233,7 @@ static int iwch_resize_cq(struct ib_cq *cq, int cqe, struct ib_udata *udata)
        struct t3_cq oldcq, newcq;
        int ret;
 
-       PDBG("%s ib_cq %p cqe %d\n", __FUNCTION__, cq, cqe);
+       PDBG("%s ib_cq %p cqe %d\n", __func__, cq, cqe);
 
        /* We don't downsize... */
        if (cqe <= cq->cqe)
@@ -281,7 +281,7 @@ static int iwch_resize_cq(struct ib_cq *cq, int cqe, struct ib_udata *udata)
        ret = cxio_destroy_cq(&chp->rhp->rdev, &oldcq);
        if (ret) {
                printk(KERN_ERR MOD "%s - cxio_destroy_cq failed %d\n",
-                       __FUNCTION__, ret);
+                       __func__, ret);
        }
 
        /* add user hooks here */
@@ -316,7 +316,7 @@ static int iwch_arm_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags flags)
                chp->cq.rptr = rptr;
        } else
                spin_lock_irqsave(&chp->lock, flag);
-       PDBG("%s rptr 0x%x\n", __FUNCTION__, chp->cq.rptr);
+       PDBG("%s rptr 0x%x\n", __func__, chp->cq.rptr);
        err = cxio_hal_cq_op(&rhp->rdev, &chp->cq, cq_op, 0);
        spin_unlock_irqrestore(&chp->lock, flag);
        if (err < 0)
@@ -337,7 +337,7 @@ static int iwch_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
        struct iwch_ucontext *ucontext;
        u64 addr;
 
-       PDBG("%s pgoff 0x%lx key 0x%x len %d\n", __FUNCTION__, vma->vm_pgoff,
+       PDBG("%s pgoff 0x%lx key 0x%x len %d\n", __func__, vma->vm_pgoff,
             key, len);
 
        if (vma->vm_start & (PAGE_SIZE-1)) {
@@ -390,7 +390,7 @@ static int iwch_deallocate_pd(struct ib_pd *pd)
 
        php = to_iwch_pd(pd);
        rhp = php->rhp;
-       PDBG("%s ibpd %p pdid 0x%x\n", __FUNCTION__, pd, php->pdid);
+       PDBG("%s ibpd %p pdid 0x%x\n", __func__, pd, php->pdid);
        cxio_hal_put_pdid(rhp->rdev.rscp, php->pdid);
        kfree(php);
        return 0;
@@ -404,7 +404,7 @@ static struct ib_pd *iwch_allocate_pd(struct ib_device *ibdev,
        u32 pdid;
        struct iwch_dev *rhp;
 
-       PDBG("%s ibdev %p\n", __FUNCTION__, ibdev);
+       PDBG("%s ibdev %p\n", __func__, ibdev);
        rhp = (struct iwch_dev *) ibdev;
        pdid = cxio_hal_get_pdid(rhp->rdev.rscp);
        if (!pdid)
@@ -422,7 +422,7 @@ static struct ib_pd *iwch_allocate_pd(struct ib_device *ibdev,
                        return ERR_PTR(-EFAULT);
                }
        }
-       PDBG("%s pdid 0x%0x ptr 0x%p\n", __FUNCTION__, pdid, php);
+       PDBG("%s pdid 0x%0x ptr 0x%p\n", __func__, pdid, php);
        return &php->ibpd;
 }
 
@@ -432,7 +432,7 @@ static int iwch_dereg_mr(struct ib_mr *ib_mr)
        struct iwch_mr *mhp;
        u32 mmid;
 
-       PDBG("%s ib_mr %p\n", __FUNCTION__, ib_mr);
+       PDBG("%s ib_mr %p\n", __func__, ib_mr);
        /* There can be no memory windows */
        if (atomic_read(&ib_mr->usecnt))
                return -EINVAL;
@@ -447,7 +447,7 @@ static int iwch_dereg_mr(struct ib_mr *ib_mr)
                kfree((void *) (unsigned long) mhp->kva);
        if (mhp->umem)
                ib_umem_release(mhp->umem);
-       PDBG("%s mmid 0x%x ptr %p\n", __FUNCTION__, mmid, mhp);
+       PDBG("%s mmid 0x%x ptr %p\n", __func__, mmid, mhp);
        kfree(mhp);
        return 0;
 }
@@ -467,7 +467,7 @@ static struct ib_mr *iwch_register_phys_mem(struct ib_pd *pd,
        struct iwch_mr *mhp;
        int ret;
 
-       PDBG("%s ib_pd %p\n", __FUNCTION__, pd);
+       PDBG("%s ib_pd %p\n", __func__, pd);
        php = to_iwch_pd(pd);
        rhp = php->rhp;
 
@@ -531,7 +531,7 @@ static int iwch_reregister_phys_mem(struct ib_mr *mr,
        int npages;
        int ret;
 
-       PDBG("%s ib_mr %p ib_pd %p\n", __FUNCTION__, mr, pd);
+       PDBG("%s ib_mr %p ib_pd %p\n", __func__, mr, pd);
 
        /* There can be no memory windows */
        if (atomic_read(&mr->usecnt))
@@ -594,7 +594,7 @@ static struct ib_mr *iwch_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
        struct iwch_mr *mhp;
        struct iwch_reg_user_mr_resp uresp;
 
-       PDBG("%s ib_pd %p\n", __FUNCTION__, pd);
+       PDBG("%s ib_pd %p\n", __func__, pd);
 
        php = to_iwch_pd(pd);
        rhp = php->rhp;
@@ -649,7 +649,7 @@ static struct ib_mr *iwch_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
        if (udata && !t3a_device(rhp)) {
                uresp.pbl_addr = (mhp->attr.pbl_addr -
                                 rhp->rdev.rnic_info.pbl_base) >> 3;
-               PDBG("%s user resp pbl_addr 0x%x\n", __FUNCTION__,
+               PDBG("%s user resp pbl_addr 0x%x\n", __func__,
                     uresp.pbl_addr);
 
                if (ib_copy_to_udata(udata, &uresp, sizeof (uresp))) {
@@ -673,7 +673,7 @@ static struct ib_mr *iwch_get_dma_mr(struct ib_pd *pd, int acc)
        u64 kva;
        struct ib_mr *ibmr;
 
-       PDBG("%s ib_pd %p\n", __FUNCTION__, pd);
+       PDBG("%s ib_pd %p\n", __func__, pd);
 
        /*
         * T3 only supports 32 bits of size.
@@ -710,7 +710,7 @@ static struct ib_mw *iwch_alloc_mw(struct ib_pd *pd)
        mhp->attr.stag = stag;
        mmid = (stag) >> 8;
        insert_handle(rhp, &rhp->mmidr, mhp, mmid);
-       PDBG("%s mmid 0x%x mhp %p stag 0x%x\n", __FUNCTION__, mmid, mhp, stag);
+       PDBG("%s mmid 0x%x mhp %p stag 0x%x\n", __func__, mmid, mhp, stag);
        return &(mhp->ibmw);
 }
 
@@ -726,7 +726,7 @@ static int iwch_dealloc_mw(struct ib_mw *mw)
        cxio_deallocate_window(&rhp->rdev, mhp->attr.stag);
        remove_handle(rhp, &rhp->mmidr, mmid);
        kfree(mhp);
-       PDBG("%s ib_mw %p mmid 0x%x ptr %p\n", __FUNCTION__, mw, mmid, mhp);
+       PDBG("%s ib_mw %p mmid 0x%x ptr %p\n", __func__, mw, mmid, mhp);
        return 0;
 }
 
@@ -754,7 +754,7 @@ static int iwch_destroy_qp(struct ib_qp *ib_qp)
        cxio_destroy_qp(&rhp->rdev, &qhp->wq,
                        ucontext ? &ucontext->uctx : &rhp->rdev.uctx);
 
-       PDBG("%s ib_qp %p qpid 0x%0x qhp %p\n", __FUNCTION__,
+       PDBG("%s ib_qp %p qpid 0x%0x qhp %p\n", __func__,
             ib_qp, qhp->wq.qpid, qhp);
        kfree(qhp);
        return 0;
@@ -773,7 +773,7 @@ static struct ib_qp *iwch_create_qp(struct ib_pd *pd,
        int wqsize, sqsize, rqsize;
        struct iwch_ucontext *ucontext;
 
-       PDBG("%s ib_pd %p\n", __FUNCTION__, pd);
+       PDBG("%s ib_pd %p\n", __func__, pd);
        if (attrs->qp_type != IB_QPT_RC)
                return ERR_PTR(-EINVAL);
        php = to_iwch_pd(pd);
@@ -805,7 +805,7 @@ static struct ib_qp *iwch_create_qp(struct ib_pd *pd,
         */
        sqsize = roundup_pow_of_two(attrs->cap.max_send_wr);
        wqsize = roundup_pow_of_two(rqsize + sqsize);
-       PDBG("%s wqsize %d sqsize %d rqsize %d\n", __FUNCTION__,
+       PDBG("%s wqsize %d sqsize %d rqsize %d\n", __func__,
             wqsize, sqsize, rqsize);
        qhp = kzalloc(sizeof(*qhp), GFP_KERNEL);
        if (!qhp)
@@ -898,7 +898,7 @@ static struct ib_qp *iwch_create_qp(struct ib_pd *pd,
        init_timer(&(qhp->timer));
        PDBG("%s sq_num_entries %d, rq_num_entries %d "
             "qpid 0x%0x qhp %p dma_addr 0x%llx size %d\n",
-            __FUNCTION__, qhp->attr.sq_num_entries, qhp->attr.rq_num_entries,
+            __func__, qhp->attr.sq_num_entries, qhp->attr.rq_num_entries,
             qhp->wq.qpid, qhp, (unsigned long long) qhp->wq.dma_addr,
             1 << qhp->wq.size_log2);
        return &qhp->ibqp;
@@ -912,7 +912,7 @@ static int iwch_ib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
        enum iwch_qp_attr_mask mask = 0;
        struct iwch_qp_attributes attrs;
 
-       PDBG("%s ib_qp %p\n", __FUNCTION__, ibqp);
+       PDBG("%s ib_qp %p\n", __func__, ibqp);
 
        /* iwarp does not support the RTR state */
        if ((attr_mask & IB_QP_STATE) && (attr->qp_state == IB_QPS_RTR))
@@ -945,20 +945,20 @@ static int iwch_ib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
 
 void iwch_qp_add_ref(struct ib_qp *qp)
 {
-       PDBG("%s ib_qp %p\n", __FUNCTION__, qp);
+       PDBG("%s ib_qp %p\n", __func__, qp);
        atomic_inc(&(to_iwch_qp(qp)->refcnt));
 }
 
 void iwch_qp_rem_ref(struct ib_qp *qp)
 {
-       PDBG("%s ib_qp %p\n", __FUNCTION__, qp);
+       PDBG("%s ib_qp %p\n", __func__, qp);
        if (atomic_dec_and_test(&(to_iwch_qp(qp)->refcnt)))
                wake_up(&(to_iwch_qp(qp)->wait));
 }
 
 static struct ib_qp *iwch_get_qp(struct ib_device *dev, int qpn)
 {
-       PDBG("%s ib_dev %p qpn 0x%x\n", __FUNCTION__, dev, qpn);
+       PDBG("%s ib_dev %p qpn 0x%x\n", __func__, dev, qpn);
        return (struct ib_qp *)get_qhp(to_iwch_dev(dev), qpn);
 }
 
@@ -966,7 +966,7 @@ static struct ib_qp *iwch_get_qp(struct ib_device *dev, int qpn)
 static int iwch_query_pkey(struct ib_device *ibdev,
                           u8 port, u16 index, u16 * pkey)
 {
-       PDBG("%s ibdev %p\n", __FUNCTION__, ibdev);
+       PDBG("%s ibdev %p\n", __func__, ibdev);
        *pkey = 0;
        return 0;
 }
@@ -977,7 +977,7 @@ static int iwch_query_gid(struct ib_device *ibdev, u8 port,
        struct iwch_dev *dev;
 
        PDBG("%s ibdev %p, port %d, index %d, gid %p\n",
-              __FUNCTION__, ibdev, port, index, gid);
+              __func__, ibdev, port, index, gid);
        dev = to_iwch_dev(ibdev);
        BUG_ON(port == 0 || port > 2);
        memset(&(gid->raw[0]), 0, sizeof(gid->raw));
@@ -990,7 +990,7 @@ static int iwch_query_device(struct ib_device *ibdev,
 {
 
        struct iwch_dev *dev;
-       PDBG("%s ibdev %p\n", __FUNCTION__, ibdev);
+       PDBG("%s ibdev %p\n", __func__, ibdev);
 
        dev = to_iwch_dev(ibdev);
        memset(props, 0, sizeof *props);
@@ -1017,7 +1017,7 @@ static int iwch_query_device(struct ib_device *ibdev,
 static int iwch_query_port(struct ib_device *ibdev,
                           u8 port, struct ib_port_attr *props)
 {
-       PDBG("%s ibdev %p\n", __FUNCTION__, ibdev);
+       PDBG("%s ibdev %p\n", __func__, ibdev);
        props->max_mtu = IB_MTU_4096;
        props->lid = 0;
        props->lmc = 0;
@@ -1045,7 +1045,7 @@ static ssize_t show_rev(struct class_device *cdev, char *buf)
 {
        struct iwch_dev *dev = container_of(cdev, struct iwch_dev,
                                            ibdev.class_dev);
-       PDBG("%s class dev 0x%p\n", __FUNCTION__, cdev);
+       PDBG("%s class dev 0x%p\n", __func__, cdev);
        return sprintf(buf, "%d\n", dev->rdev.t3cdev_p->type);
 }
 
@@ -1056,7 +1056,7 @@ static ssize_t show_fw_ver(struct class_device *cdev, char *buf)
        struct ethtool_drvinfo info;
        struct net_device *lldev = dev->rdev.t3cdev_p->lldev;
 
-       PDBG("%s class dev 0x%p\n", __FUNCTION__, cdev);
+       PDBG("%s class dev 0x%p\n", __func__, cdev);
        rtnl_lock();
        lldev->ethtool_ops->get_drvinfo(lldev, &info);
        rtnl_unlock();
@@ -1070,7 +1070,7 @@ static ssize_t show_hca(struct class_device *cdev, char *buf)
        struct ethtool_drvinfo info;
        struct net_device *lldev = dev->rdev.t3cdev_p->lldev;
 
-       PDBG("%s class dev 0x%p\n", __FUNCTION__, cdev);
+       PDBG("%s class dev 0x%p\n", __func__, cdev);
        rtnl_lock();
        lldev->ethtool_ops->get_drvinfo(lldev, &info);
        rtnl_unlock();
@@ -1081,7 +1081,7 @@ static ssize_t show_board(struct class_device *cdev, char *buf)
 {
        struct iwch_dev *dev = container_of(cdev, struct iwch_dev,
                                            ibdev.class_dev);
-       PDBG("%s class dev 0x%p\n", __FUNCTION__, dev);
+       PDBG("%s class dev 0x%p\n", __func__, dev);
        return sprintf(buf, "%x.%x\n", dev->rdev.rnic_info.pdev->vendor,
                                       dev->rdev.rnic_info.pdev->device);
 }
@@ -1103,7 +1103,7 @@ int iwch_register_device(struct iwch_dev *dev)
        int ret;
        int i;
 
-       PDBG("%s iwch_dev %p\n", __FUNCTION__, dev);
+       PDBG("%s iwch_dev %p\n", __func__, dev);
        strlcpy(dev->ibdev.name, "cxgb3_%d", IB_DEVICE_NAME_MAX);
        memset(&dev->ibdev.node_guid, 0, sizeof(dev->ibdev.node_guid));
        memcpy(&dev->ibdev.node_guid, dev->rdev.t3cdev_p->lldev->dev_addr, 6);
@@ -1207,7 +1207,7 @@ void iwch_unregister_device(struct iwch_dev *dev)
 {
        int i;
 
-       PDBG("%s iwch_dev %p\n", __FUNCTION__, dev);
+       PDBG("%s iwch_dev %p\n", __func__, dev);
        for (i = 0; i < ARRAY_SIZE(iwch_class_attributes); ++i)
                class_device_remove_file(&dev->ibdev.class_dev,
                                         iwch_class_attributes[i]);
index 48833f3f3bd03779e4139b6db8e91166af0fff04..61356f91109d8fd96e611cc55bb40a1b64f20997 100644 (file)
@@ -213,7 +213,7 @@ static inline struct iwch_mm_entry *remove_mmap(struct iwch_ucontext *ucontext,
                if (mm->key == key && mm->len == len) {
                        list_del_init(&mm->entry);
                        spin_unlock(&ucontext->mmap_lock);
-                       PDBG("%s key 0x%x addr 0x%llx len %d\n", __FUNCTION__,
+                       PDBG("%s key 0x%x addr 0x%llx len %d\n", __func__,
                             key, (unsigned long long) mm->addr, mm->len);
                        return mm;
                }
@@ -226,7 +226,7 @@ static inline void insert_mmap(struct iwch_ucontext *ucontext,
                               struct iwch_mm_entry *mm)
 {
        spin_lock(&ucontext->mmap_lock);
-       PDBG("%s key 0x%x addr 0x%llx len %d\n", __FUNCTION__,
+       PDBG("%s key 0x%x addr 0x%llx len %d\n", __func__,
             mm->key, (unsigned long long) mm->addr, mm->len);
        list_add_tail(&mm->entry, &ucontext->mmaps);
        spin_unlock(&ucontext->mmap_lock);
index ea2cdd73dd850d780307c4d530ba685500eaa264..bc5d9b0813e5ec7bae9afa7659d890d9ac65aaab 100644 (file)
@@ -168,30 +168,30 @@ static int iwch_sgl2pbl_map(struct iwch_dev *rhp, struct ib_sge *sg_list,
 
                mhp = get_mhp(rhp, (sg_list[i].lkey) >> 8);
                if (!mhp) {
-                       PDBG("%s %d\n", __FUNCTION__, __LINE__);
+                       PDBG("%s %d\n", __func__, __LINE__);
                        return -EIO;
                }
                if (!mhp->attr.state) {
-                       PDBG("%s %d\n", __FUNCTION__, __LINE__);
+                       PDBG("%s %d\n", __func__, __LINE__);
                        return -EIO;
                }
                if (mhp->attr.zbva) {
-                       PDBG("%s %d\n", __FUNCTION__, __LINE__);
+                       PDBG("%s %d\n", __func__, __LINE__);
                        return -EIO;
                }
 
                if (sg_list[i].addr < mhp->attr.va_fbo) {
-                       PDBG("%s %d\n", __FUNCTION__, __LINE__);
+                       PDBG("%s %d\n", __func__, __LINE__);
                        return -EINVAL;
                }
                if (sg_list[i].addr + ((u64) sg_list[i].length) <
                    sg_list[i].addr) {
-                       PDBG("%s %d\n", __FUNCTION__, __LINE__);
+                       PDBG("%s %d\n", __func__, __LINE__);
                        return -EINVAL;
                }
                if (sg_list[i].addr + ((u64) sg_list[i].length) >
                    mhp->attr.va_fbo + ((u64) mhp->attr.len)) {
-                       PDBG("%s %d\n", __FUNCTION__, __LINE__);
+                       PDBG("%s %d\n", __func__, __LINE__);
                        return -EINVAL;
                }
                offset = sg_list[i].addr - mhp->attr.va_fbo;
@@ -290,7 +290,7 @@ int iwch_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                                qhp->wq.oldest_read = sqp;
                        break;
                default:
-                       PDBG("%s post of type=%d TBD!\n", __FUNCTION__,
+                       PDBG("%s post of type=%d TBD!\n", __func__,
                             wr->opcode);
                        err = -EINVAL;
                }
@@ -309,7 +309,7 @@ int iwch_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                               Q_GENBIT(qhp->wq.wptr, qhp->wq.size_log2),
                               0, t3_wr_flit_cnt);
                PDBG("%s cookie 0x%llx wq idx 0x%x swsq idx %ld opcode %d\n",
-                    __FUNCTION__, (unsigned long long) wr->wr_id, idx,
+                    __func__, (unsigned long long) wr->wr_id, idx,
                     Q_PTR2IDX(qhp->wq.sq_wptr, qhp->wq.sq_size_log2),
                     sqp->opcode);
                wr = wr->next;
@@ -361,7 +361,7 @@ int iwch_post_receive(struct ib_qp *ibqp, struct ib_recv_wr *wr,
                               Q_GENBIT(qhp->wq.wptr, qhp->wq.size_log2),
                               0, sizeof(struct t3_receive_wr) >> 3);
                PDBG("%s cookie 0x%llx idx 0x%x rq_wptr 0x%x rw_rptr 0x%x "
-                    "wqe %p \n", __FUNCTION__, (unsigned long long) wr->wr_id,
+                    "wqe %p \n", __func__, (unsigned long long) wr->wr_id,
                     idx, qhp->wq.rq_wptr, qhp->wq.rq_rptr, wqe);
                ++(qhp->wq.rq_wptr);
                ++(qhp->wq.wptr);
@@ -407,7 +407,7 @@ int iwch_bind_mw(struct ib_qp *qp,
                return -ENOMEM;
        }
        idx = Q_PTR2IDX(qhp->wq.wptr, qhp->wq.size_log2);
-       PDBG("%s: idx 0x%0x, mw 0x%p, mw_bind 0x%p\n", __FUNCTION__, idx,
+       PDBG("%s: idx 0x%0x, mw 0x%p, mw_bind 0x%p\n", __func__, idx,
             mw, mw_bind);
        wqe = (union t3_wr *) (qhp->wq.queue + idx);
 
@@ -595,10 +595,10 @@ int iwch_post_terminate(struct iwch_qp *qhp, struct respQ_msg_t *rsp_msg)
        struct terminate_message *term;
        struct sk_buff *skb;
 
-       PDBG("%s %d\n", __FUNCTION__, __LINE__);
+       PDBG("%s %d\n", __func__, __LINE__);
        skb = alloc_skb(40, GFP_ATOMIC);
        if (!skb) {
-               printk(KERN_ERR "%s cannot send TERMINATE!\n", __FUNCTION__);
+               printk(KERN_ERR "%s cannot send TERMINATE!\n", __func__);
                return -ENOMEM;
        }
        wqe = (union t3_wr *)skb_put(skb, 40);
@@ -629,7 +629,7 @@ static void __flush_qp(struct iwch_qp *qhp, unsigned long *flag)
        rchp = get_chp(qhp->rhp, qhp->attr.rcq);
        schp = get_chp(qhp->rhp, qhp->attr.scq);
 
-       PDBG("%s qhp %p rchp %p schp %p\n", __FUNCTION__, qhp, rchp, schp);
+       PDBG("%s qhp %p rchp %p schp %p\n", __func__, qhp, rchp, schp);
        /* take a ref on the qhp since we must release the lock */
        atomic_inc(&qhp->refcnt);
        spin_unlock_irqrestore(&qhp->lock, *flag);
@@ -720,11 +720,11 @@ static int rdma_init(struct iwch_dev *rhp, struct iwch_qp *qhp,
        init_attr.flags |= capable(CAP_NET_BIND_SERVICE) ? PRIV_QP : 0;
        init_attr.irs = qhp->ep->rcv_seq;
        PDBG("%s init_attr.rq_addr 0x%x init_attr.rq_size = %d "
-            "flags 0x%x qpcaps 0x%x\n", __FUNCTION__,
+            "flags 0x%x qpcaps 0x%x\n", __func__,
             init_attr.rq_addr, init_attr.rq_size,
             init_attr.flags, init_attr.qpcaps);
        ret = cxio_rdma_init(&rhp->rdev, &init_attr);
-       PDBG("%s ret %d\n", __FUNCTION__, ret);
+       PDBG("%s ret %d\n", __func__, ret);
        return ret;
 }
 
@@ -742,7 +742,7 @@ int iwch_modify_qp(struct iwch_dev *rhp, struct iwch_qp *qhp,
        int free = 0;
        struct iwch_ep *ep = NULL;
 
-       PDBG("%s qhp %p qpid 0x%x ep %p state %d -> %d\n", __FUNCTION__,
+       PDBG("%s qhp %p qpid 0x%x ep %p state %d -> %d\n", __func__,
             qhp, qhp->wq.qpid, qhp->ep, qhp->attr.state,
             (mask & IWCH_QP_ATTR_NEXT_STATE) ? attrs->next_state : -1);
 
@@ -899,14 +899,14 @@ int iwch_modify_qp(struct iwch_dev *rhp, struct iwch_qp *qhp,
                break;
        default:
                printk(KERN_ERR "%s in a bad state %d\n",
-                      __FUNCTION__, qhp->attr.state);
+                      __func__, qhp->attr.state);
                ret = -EINVAL;
                goto err;
                break;
        }
        goto out;
 err:
-       PDBG("%s disassociating ep %p qpid 0x%x\n", __FUNCTION__, qhp->ep,
+       PDBG("%s disassociating ep %p qpid 0x%x\n", __func__, qhp->ep,
             qhp->wq.qpid);
 
        /* disassociate the LLP connection */
@@ -939,7 +939,7 @@ out:
        if (free)
                put_ep(&ep->com);
 
-       PDBG("%s exit state %d\n", __FUNCTION__, qhp->attr.state);
+       PDBG("%s exit state %d\n", __func__, qhp->attr.state);
        return ret;
 }
 
index 4a8346a2bc9e8c1602d04711bfa4cd55d980b724..ec950bf8c479b220143c54289fb90a18bd176d64 100644 (file)
@@ -73,37 +73,37 @@ extern int ehca_debug_level;
                if (unlikely(ehca_debug_level)) \
                        dev_printk(KERN_DEBUG, (ib_dev)->dma_device, \
                                   "PU%04x EHCA_DBG:%s " format "\n", \
-                                  raw_smp_processor_id(), __FUNCTION__, \
+                                  raw_smp_processor_id(), __func__, \
                                   ## arg); \
        } while (0)
 
 #define ehca_info(ib_dev, format, arg...) \
        dev_info((ib_dev)->dma_device, "PU%04x EHCA_INFO:%s " format "\n", \
-                raw_smp_processor_id(), __FUNCTION__, ## arg)
+                raw_smp_processor_id(), __func__, ## arg)
 
 #define ehca_warn(ib_dev, format, arg...) \
        dev_warn((ib_dev)->dma_device, "PU%04x EHCA_WARN:%s " format "\n", \
-                raw_smp_processor_id(), __FUNCTION__, ## arg)
+                raw_smp_processor_id(), __func__, ## arg)
 
 #define ehca_err(ib_dev, format, arg...) \
        dev_err((ib_dev)->dma_device, "PU%04x EHCA_ERR:%s " format "\n", \
-               raw_smp_processor_id(), __FUNCTION__, ## arg)
+               raw_smp_processor_id(), __func__, ## arg)
 
 /* use this one only if no ib_dev available */
 #define ehca_gen_dbg(format, arg...) \
        do { \
                if (unlikely(ehca_debug_level)) \
                        printk(KERN_DEBUG "PU%04x EHCA_DBG:%s " format "\n", \
-                              raw_smp_processor_id(), __FUNCTION__, ## arg); \
+                              raw_smp_processor_id(), __func__, ## arg); \
        } while (0)
 
 #define ehca_gen_warn(format, arg...) \
        printk(KERN_INFO "PU%04x EHCA_WARN:%s " format "\n", \
-              raw_smp_processor_id(), __FUNCTION__, ## arg)
+              raw_smp_processor_id(), __func__, ## arg)
 
 #define ehca_gen_err(format, arg...) \
        printk(KERN_ERR "PU%04x EHCA_ERR:%s " format "\n", \
-              raw_smp_processor_id(), __FUNCTION__, ## arg)
+              raw_smp_processor_id(), __func__, ## arg)
 
 /**
  * ehca_dmp - printk a memory block, whose length is n*8 bytes.
@@ -118,7 +118,7 @@ extern int ehca_debug_level;
                for (x = 0; x < l; x += 16) { \
                        printk(KERN_INFO "EHCA_DMP:%s " format \
                               " adr=%p ofs=%04x %016lx %016lx\n", \
-                              __FUNCTION__, ##args, deb, x, \
+                              __func__, ##args, deb, x, \
                               *((u64 *)&deb[0]), *((u64 *)&deb[8])); \
                        deb += 16; \
                } \
index dcb601c3dec172ff024648ad22165e5b583ce6f3..7a89cd7327e2646251535a5f02e4b45cf08a6163 100644 (file)
@@ -303,7 +303,7 @@ void nes_rem_ref(struct ib_qp *ibqp)
 
        if (atomic_read(&nesqp->refcount) == 0) {
                printk(KERN_INFO PFX "%s: Reference count already 0 for QP%d, last aeq = 0x%04X.\n",
-                               __FUNCTION__, ibqp->qp_num, nesqp->last_aeq);
+                               __func__, ibqp->qp_num, nesqp->last_aeq);
                BUG();
        }
 
index bd92be79b63ef0b13c2bbdefb6d498405f298f39..1626124a156d53615e0fafe9ba1eb03990d01d77 100644 (file)
 #ifdef CONFIG_INFINIBAND_NES_DEBUG
 #define nes_debug(level, fmt, args...) \
        if (level & nes_debug_level) \
-               printk(KERN_ERR PFX "%s[%u]: " fmt, __FUNCTION__, __LINE__, ##args)
+               printk(KERN_ERR PFX "%s[%u]: " fmt, __func__, __LINE__, ##args)
 
 #define assert(expr)                                                \
 if (!(expr)) {                                                       \
        printk(KERN_ERR PFX "Assertion failed! %s, %s, %s, line %d\n",  \
-                  #expr, __FILE__, __FUNCTION__, __LINE__);                \
+                  #expr, __FILE__, __func__, __LINE__);                \
 }
 
 #define NES_EVENT_TIMEOUT   1200000
@@ -399,7 +399,7 @@ static inline int nes_alloc_resource(struct nes_adapter *nesadapter,
        if (resource_num >= max_resources) {
                resource_num = find_first_zero_bit(resource_array, max_resources);
                if (resource_num >= max_resources) {
-                       printk(KERN_ERR PFX "%s: No available resourcess.\n", __FUNCTION__);
+                       printk(KERN_ERR PFX "%s: No available resourcess.\n", __func__);
                        spin_unlock_irqrestore(&nesadapter->resource_lock, flags);
                        return -EMFILE;
                }
index 456da13b68de1972ddc81795901012bf2e684042..d40465c45906bba7d43f84beee7b363284d2c015 100644 (file)
@@ -1038,7 +1038,7 @@ static void nes_addr_send_arp(u32 dst_ip)
        fl.nl_u.ip4_u.daddr = htonl(dst_ip);
        if (ip_route_output_key(&init_net, &rt, &fl)) {
                printk("%s: ip_route_output_key failed for 0x%08X\n",
-                               __FUNCTION__, dst_ip);
+                               __func__, dst_ip);
                return;
        }
 
@@ -1263,7 +1263,7 @@ static int process_options(struct nes_cm_node *cm_node, u8 *optionsloc, u32 opti
                                continue;
                        case OPTION_NUMBER_MSS:
                                nes_debug(NES_DBG_CM, "%s: MSS Length: %d Offset: %d Size: %d\n",
-                                               __FUNCTION__,
+                                               __func__,
                                                all_options->as_mss.length, offset, optionsize);
                                got_mss_option = 1;
                                if (all_options->as_mss.length != 4) {
@@ -1384,7 +1384,7 @@ static int process_packet(struct nes_cm_node *cm_node, struct sk_buff *skb,
        if (optionsize) {
                u8 *optionsloc = (u8 *)&tcph[1];
                if (process_options(cm_node, optionsloc, optionsize, (u32)tcph->syn)) {
-                       nes_debug(NES_DBG_CM, "%s: Node %p, Sending RESET\n", __FUNCTION__, cm_node);
+                       nes_debug(NES_DBG_CM, "%s: Node %p, Sending RESET\n", __func__, cm_node);
                        send_reset(cm_node);
                        if (cm_node->state != NES_CM_STATE_SYN_SENT)
                        rem_ref_cm_node(cm_core, cm_node);
@@ -2507,7 +2507,7 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
        }
        if (ret)
                printk("%s[%u] OFA CM event_handler returned, ret=%d\n",
-                               __FUNCTION__, __LINE__, ret);
+                               __func__, __LINE__, ret);
 
        return 0;
 }
@@ -2675,7 +2675,7 @@ int nes_create_listen(struct iw_cm_id *cm_id, int backlog)
        cm_node = g_cm_core->api->listen(g_cm_core, nesvnic, &cm_info);
        if (!cm_node) {
                printk("%s[%u] Error returned from listen API call\n",
-                               __FUNCTION__, __LINE__);
+                               __func__, __LINE__);
                return -ENOMEM;
        }
 
@@ -2889,7 +2889,7 @@ static void cm_event_connected(struct nes_cm_event *event)
 
        if (ret)
                printk("%s[%u] OFA CM event_handler returned, ret=%d\n",
-                               __FUNCTION__, __LINE__, ret);
+                               __func__, __LINE__, ret);
        nes_debug(NES_DBG_CM, "Exiting connect thread for QP%u. jiffies = %lu\n",
                        nesqp->hwqp.qp_id, jiffies );
 
@@ -2944,7 +2944,7 @@ static void cm_event_connect_error(struct nes_cm_event *event)
        nes_debug(NES_DBG_CM, "OFA CM event_handler returned, ret=%d\n", ret);
        if (ret)
                printk("%s[%u] OFA CM event_handler returned, ret=%d\n",
-                               __FUNCTION__, __LINE__, ret);
+                               __func__, __LINE__, ret);
        nes_rem_ref(&nesqp->ibqp);
                cm_id->rem_ref(cm_id);
 
@@ -3032,7 +3032,7 @@ static void cm_event_mpa_req(struct nes_cm_event *event)
        ret = cm_id->event_handler(cm_id, &cm_event);
        if (ret)
                printk("%s[%u] OFA CM event_handler returned, ret=%d\n",
-                               __FUNCTION__, __LINE__, ret);
+                               __func__, __LINE__, ret);
 
        return;
 }
index 8b29bd82f3a5d20d4fbfd85910d6b817f22a718b..134189d77ed32411132c6c451dc9c457180e613c 100644 (file)
@@ -381,7 +381,7 @@ struct nes_adapter *nes_init_adapter(struct nes_device *nesdev, u8 hw_rev) {
                nesadapter->et_use_adaptive_rx_coalesce = 1;
                nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
                nesadapter->et_rx_coalesce_usecs_irq = 0;
-               printk(PFX "%s: Using Adaptive Interrupt Moderation\n", __FUNCTION__);
+               printk(PFX "%s: Using Adaptive Interrupt Moderation\n", __func__);
        }
        /* Setup and enable the periodic timer */
        if (nesadapter->et_rx_coalesce_usecs_irq)
@@ -583,7 +583,7 @@ struct nes_adapter *nes_init_adapter(struct nes_device *nesdev, u8 hw_rev) {
                if (vendor_id == 0xffff)
                        break;
        }
-       nes_debug(NES_DBG_INIT, "%s %d functions found for %s.\n", __FUNCTION__,
+       nes_debug(NES_DBG_INIT, "%s %d functions found for %s.\n", __func__,
                func_index, pci_name(nesdev->pcidev));
        nesadapter->adapter_fcn_count = func_index;
 
@@ -751,7 +751,7 @@ static int nes_init_serdes(struct nes_device *nesdev, u8 hw_rev, u8 port_count,
                                & 0x0000000f)) != 0x0000000f) && (i++ < 5000))
                                mdelay(1);
                        if (i >= 5000) {
-                               printk("%s: Init: serdes 1 not ready, status=%x\n", __FUNCTION__, u32temp);
+                               printk("%s: Init: serdes 1 not ready, status=%x\n", __func__, u32temp);
                                /* return 1; */
                        }
                        nes_write_indexed(nesdev, NES_IDX_ETH_SERDES_TX_EMP1, 0x000bdef7);
@@ -1216,7 +1216,7 @@ int nes_init_phy(struct nes_device *nesdev)
        if (nesadapter->OneG_Mode) {
                nes_debug(NES_DBG_PHY, "1G PHY, mac_index = %d.\n", mac_index);
                if (nesadapter->phy_type[mac_index] == NES_PHY_TYPE_1G) {
-                       printk(PFX "%s: Programming mdc config for 1G\n", __FUNCTION__);
+                       printk(PFX "%s: Programming mdc config for 1G\n", __func__);
                        tx_config = nes_read_indexed(nesdev, NES_IDX_MAC_TX_CONFIG);
                        tx_config |= 0x04;
                        nes_write_indexed(nesdev, NES_IDX_MAC_TX_CONFIG, tx_config);
@@ -1370,7 +1370,7 @@ static void nes_replenish_nic_rq(struct nes_vnic *nesvnic)
 static void nes_rq_wqes_timeout(unsigned long parm)
 {
        struct nes_vnic *nesvnic = (struct nes_vnic *)parm;
-       printk("%s: Timer fired.\n", __FUNCTION__);
+       printk("%s: Timer fired.\n", __func__);
        atomic_set(&nesvnic->rx_skb_timer_running, 0);
        if (atomic_read(&nesvnic->rx_skbs_needed))
                nes_replenish_nic_rq(nesvnic);
@@ -2175,7 +2175,7 @@ static void nes_process_mac_intr(struct nes_device *nesdev, u32 mac_number)
                                temp_phy_data = phy_data;
                        } while (1);
                        nes_debug(NES_DBG_PHY, "%s: Phy data = 0x%04X, link was %s.\n",
-                               __FUNCTION__, phy_data, nesadapter->mac_link_down ? "DOWN" : "UP");
+                               __func__, phy_data, nesadapter->mac_link_down ? "DOWN" : "UP");
 
                } else {
                        phy_data = (0x0f0f0000 == (pcs_control_status & 0x0f1f0000)) ? 4 : 0;
@@ -2832,7 +2832,7 @@ static void nes_process_iwarp_aeqe(struct nes_device *nesdev,
                                        le32_to_cpu(aeqe->aeqe_words[NES_AEQE_COMP_QP_CQ_ID_IDX]));
                        if (resource_allocated) {
                                printk(KERN_ERR PFX "%s: Processing an NES_AEQE_AEID_CQ_OPERATION_ERROR event on CQ%u\n",
-                                               __FUNCTION__, le32_to_cpu(aeqe->aeqe_words[NES_AEQE_COMP_QP_CQ_ID_IDX]));
+                                               __func__, le32_to_cpu(aeqe->aeqe_words[NES_AEQE_COMP_QP_CQ_ID_IDX]));
                        }
                        break;
                case NES_AEQE_AEID_DDP_UBE_DDP_MESSAGE_TOO_LONG_FOR_AVAILABLE_BUFFER:
index 840d5190009a043bb4ffea950575a90f522cc8fa..34166641f207c52571546b7d0855ce823ce0f7c9 100644 (file)
@@ -802,7 +802,7 @@ static int nes_netdev_set_mac_address(struct net_device *netdev, void *p)
 
        memcpy(netdev->dev_addr, mac_addr->sa_data, netdev->addr_len);
        printk(PFX "%s: Address length = %d, Address = %02X%02X%02X%02X%02X%02X..\n",
-                  __FUNCTION__, netdev->addr_len,
+                  __func__, netdev->addr_len,
                   mac_addr->sa_data[0], mac_addr->sa_data[1],
                   mac_addr->sa_data[2], mac_addr->sa_data[3],
                   mac_addr->sa_data[4], mac_addr->sa_data[5]);
index c4ec6ac634618c7e325c9fbfb42dfa3985572396..f9db07c2717d81e7f4e7eb7ecdcccc20d303f3ed 100644 (file)
@@ -566,7 +566,7 @@ struct nes_cqp_request *nes_get_cqp_request(struct nes_device *nesdev)
                                cqp_request);
        } else
                printk(KERN_ERR PFX "%s: Could not allocated a CQP request.\n",
-                          __FUNCTION__);
+                          __func__);
 
        return cqp_request;
 }
index 245970302678dfa62b5d029fcfbf8706dd795895..46b3b8ebcc14d67889bbd6ed7ef9b4f320d4716e 100644 (file)
@@ -1909,13 +1909,13 @@ static int nes_destroy_cq(struct ib_cq *ib_cq)
                nesadapter->free_256pbl++;
                if (nesadapter->free_256pbl > nesadapter->max_256pbl) {
                        printk(KERN_ERR PFX "%s: free 256B PBLs(%u) has exceeded the max(%u)\n",
-                                       __FUNCTION__, nesadapter->free_256pbl, nesadapter->max_256pbl);
+                                       __func__, nesadapter->free_256pbl, nesadapter->max_256pbl);
                }
        } else if (nescq->virtual_cq == 2) {
                nesadapter->free_4kpbl++;
                if (nesadapter->free_4kpbl > nesadapter->max_4kpbl) {
                        printk(KERN_ERR PFX "%s: free 4K PBLs(%u) has exceeded the max(%u)\n",
-                                       __FUNCTION__, nesadapter->free_4kpbl, nesadapter->max_4kpbl);
+                                       __func__, nesadapter->free_4kpbl, nesadapter->max_4kpbl);
                }
                opcode |= NES_CQP_CQ_4KB_CHUNK;
        }