/*
 * Copyright (c) 2005 Ammasso, Inc.  All rights reserved.
 * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 */
#include <linux/slab.h>

#include "c2.h"
#include "c2_wr.h"
#include "c2_vq.h"
#include <rdma/iw_cm.h>

int c2_llp_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param)
{
        struct c2_dev *c2dev = to_c2dev(cm_id->device);
        struct ib_qp *ibqp;
        struct c2_qp *qp;
        struct c2wr_qp_connect_req *wr; /* variable size needs a malloc. */
        struct c2_vq_req *vq_req;
        int err;
        struct sockaddr_in *raddr = (struct sockaddr_in *)&cm_id->remote_addr;

        if (cm_id->remote_addr.ss_family != AF_INET)
                return -ENOSYS;

        ibqp = c2_get_qp(cm_id->device, iw_param->qpn);
        if (!ibqp)
                return -EINVAL;
        qp = to_c2qp(ibqp);

        /* Associate QP <--> CM_ID */
        cm_id->provider_data = qp;
        cm_id->add_ref(cm_id);
        qp->cm_id = cm_id;

        /*
         * only support the max private_data length
         */
        if (iw_param->private_data_len > C2_MAX_PRIVATE_DATA_SIZE) {
                err = -EINVAL;
                goto bail0;
        }
        /*
         * Set the rdma read limits
         */
        err = c2_qp_set_read_limits(c2dev, qp, iw_param->ord, iw_param->ird);
        if (err)
                goto bail0;

        /*
         * Create and send a WR_QP_CONNECT...
         */
        wr = kmalloc(c2dev->req_vq.msg_size, GFP_KERNEL);
        if (!wr) {
                err = -ENOMEM;
                goto bail0;
        }

        vq_req = vq_req_alloc(c2dev);
        if (!vq_req) {
                err = -ENOMEM;
                goto bail1;
        }

        c2_wr_set_id(wr, CCWR_QP_CONNECT);
        wr->hdr.context = 0;
        wr->rnic_handle = c2dev->adapter_handle;
        wr->qp_handle = qp->adapter_handle;

        wr->remote_addr = raddr->sin_addr.s_addr;
        wr->remote_port = raddr->sin_port;

        /*
         * Move any private data from the callers's buf into
         * the WR.
         */
        if (iw_param->private_data) {
                wr->private_data_length =
                        cpu_to_be32(iw_param->private_data_len);
                memcpy(&wr->private_data[0], iw_param->private_data,
                       iw_param->private_data_len);
        } else
                wr->private_data_length = 0;

        /*
         * Send WR to adapter.  NOTE: There is no synch reply from
         * the adapter.
         */
        err = vq_send_wr(c2dev, (union c2wr *) wr);
        vq_req_free(c2dev, vq_req);

 bail1:
        kfree(wr);
 bail0:
        if (err) {
                /*
                 * If we fail, release reference on QP and
                 * disassociate QP from CM_ID
                 */
                cm_id->provider_data = NULL;
                qp->cm_id = NULL;
                cm_id->rem_ref(cm_id);
        }
        return err;
}

int c2_llp_service_create(struct iw_cm_id *cm_id, int backlog)
{
        struct c2_dev *c2dev;
        struct c2wr_ep_listen_create_req wr;
        struct c2wr_ep_listen_create_rep *reply;
        struct c2_vq_req *vq_req;
        int err;
        struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->local_addr;

        if (cm_id->local_addr.ss_family != AF_INET)
                return -ENOSYS;

        c2dev = to_c2dev(cm_id->device);
        if (c2dev == NULL)
                return -EINVAL;

        /*
         * Allocate verbs request.
         */
        vq_req = vq_req_alloc(c2dev);
        if (!vq_req)
                return -ENOMEM;

        /*
         * Build the WR
         */
        c2_wr_set_id(&wr, CCWR_EP_LISTEN_CREATE);
        wr.hdr.context = (u64) (unsigned long) vq_req;
        wr.rnic_handle = c2dev->adapter_handle;
        wr.local_addr = laddr->sin_addr.s_addr;
        wr.local_port = laddr->sin_port;
        wr.backlog = cpu_to_be32(backlog);
        wr.user_context = (u64) (unsigned long) cm_id;

        /*
         * Reference the request struct.  Dereferenced in the int handler.
         */
        vq_req_get(c2dev, vq_req);

        /*
         * Send WR to adapter
         */
        err = vq_send_wr(c2dev, (union c2wr *) & wr);
        if (err) {
                vq_req_put(c2dev, vq_req);
                goto bail0;
        }

        /*
         * Wait for reply from adapter
         */
        err = vq_wait_for_reply(c2dev, vq_req);
        if (err)
                goto bail0;

        /*
         * Process reply
         */
        reply =
            (struct c2wr_ep_listen_create_rep *) (unsigned long) vq_req->reply_msg;
        if (!reply) {
                err = -ENOMEM;
                goto bail1;
        }

        if ((err = c2_errno(reply)) != 0)
                goto bail1;

        /*
         * Keep the adapter handle. Used in subsequent destroy
         */
        cm_id->provider_data = (void*)(unsigned long) reply->ep_handle;

        /*
         * free vq stuff
         */
        vq_repbuf_free(c2dev, reply);
        vq_req_free(c2dev, vq_req);

        return 0;

 bail1:
        vq_repbuf_free(c2dev, reply);
 bail0:
        vq_req_free(c2dev, vq_req);
        return err;
}


int c2_llp_service_destroy(struct iw_cm_id *cm_id)
{

        struct c2_dev *c2dev;
        struct c2wr_ep_listen_destroy_req wr;
        struct c2wr_ep_listen_destroy_rep *reply;
        struct c2_vq_req *vq_req;
        int err;

        c2dev = to_c2dev(cm_id->device);
        if (c2dev == NULL)
                return -EINVAL;

        /*
         * Allocate verbs request.
         */
        vq_req = vq_req_alloc(c2dev);
        if (!vq_req)
                return -ENOMEM;

        /*
         * Build the WR
         */
        c2_wr_set_id(&wr, CCWR_EP_LISTEN_DESTROY);
        wr.hdr.context = (unsigned long) vq_req;
        wr.rnic_handle = c2dev->adapter_handle;
        wr.ep_handle = (u32)(unsigned long)cm_id->provider_data;

        /*
         * reference the request struct.  dereferenced in the int handler.
         */
        vq_req_get(c2dev, vq_req);

        /*
         * Send WR to adapter
         */
        err = vq_send_wr(c2dev, (union c2wr *) & wr);
        if (err) {
                vq_req_put(c2dev, vq_req);
                goto bail0;
        }

        /*
         * Wait for reply from adapter
         */
        err = vq_wait_for_reply(c2dev, vq_req);
        if (err)
                goto bail0;

        /*
         * Process reply
         */
        reply=(struct c2wr_ep_listen_destroy_rep *)(unsigned long)vq_req->reply_msg;
        if (!reply) {
                err = -ENOMEM;
                goto bail0;
        }
        if ((err = c2_errno(reply)) != 0)
                goto bail1;

 bail1:
        vq_repbuf_free(c2dev, reply);
 bail0:
        vq_req_free(c2dev, vq_req);
        return err;
}

int c2_llp_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param)
{
        struct c2_dev *c2dev = to_c2dev(cm_id->device);
        struct c2_qp *qp;
        struct ib_qp *ibqp;
        struct c2wr_cr_accept_req *wr;  /* variable length WR */
        struct c2_vq_req *vq_req;
        struct c2wr_cr_accept_rep *reply;       /* VQ Reply msg ptr. */
        int err;

        ibqp = c2_get_qp(cm_id->device, iw_param->qpn);
        if (!ibqp)
                return -EINVAL;
        qp = to_c2qp(ibqp);

        /* Set the RDMA read limits */
        err = c2_qp_set_read_limits(c2dev, qp, iw_param->ord, iw_param->ird);
        if (err)
                goto bail0;

        /* Allocate verbs request. */
        vq_req = vq_req_alloc(c2dev);
        if (!vq_req) {
                err = -ENOMEM;
                goto bail0;
        }
        vq_req->qp = qp;
        vq_req->cm_id = cm_id;
        vq_req->event = IW_CM_EVENT_ESTABLISHED;

        wr = kmalloc(c2dev->req_vq.msg_size, GFP_KERNEL);
        if (!wr) {
                err = -ENOMEM;
                goto bail1;
        }

        /* Build the WR */
        c2_wr_set_id(wr, CCWR_CR_ACCEPT);
        wr->hdr.context = (unsigned long) vq_req;
        wr->rnic_handle = c2dev->adapter_handle;
        wr->ep_handle = (u32) (unsigned long) cm_id->provider_data;
        wr->qp_handle = qp->adapter_handle;

        /* Replace the cr_handle with the QP after accept */
        cm_id->provider_data = qp;
        cm_id->add_ref(cm_id);
        qp->cm_id = cm_id;

        cm_id->provider_data = qp;

        /* Validate private_data length */
        if (iw_param->private_data_len > C2_MAX_PRIVATE_DATA_SIZE) {
                err = -EINVAL;
                goto bail1;
        }

        if (iw_param->private_data) {
                wr->private_data_length = cpu_to_be32(iw_param->private_data_len);
                memcpy(&wr->private_data[0],
                       iw_param->private_data, iw_param->private_data_len);
        } else
                wr->private_data_length = 0;

        /* Reference the request struct.  Dereferenced in the int handler. */
        vq_req_get(c2dev, vq_req);

        /* Send WR to adapter */
        err = vq_send_wr(c2dev, (union c2wr *) wr);
        if (err) {
                vq_req_put(c2dev, vq_req);
                goto bail1;
        }

        /* Wait for reply from adapter */
        err = vq_wait_for_reply(c2dev, vq_req);
        if (err)
                goto bail1;

        /* Check that reply is present */
        reply = (struct c2wr_cr_accept_rep *) (unsigned long) vq_req->reply_msg;
        if (!reply) {
                err = -ENOMEM;
                goto bail1;
        }

        err = c2_errno(reply);
        vq_repbuf_free(c2dev, reply);

        if (!err)
                c2_set_qp_state(qp, C2_QP_STATE_RTS);
 bail1:
        kfree(wr);
        vq_req_free(c2dev, vq_req);
 bail0:
        if (err) {
                /*
                 * If we fail, release reference on QP and
                 * disassociate QP from CM_ID
                 */
                cm_id->provider_data = NULL;
                qp->cm_id = NULL;
                cm_id->rem_ref(cm_id);
        }
        return err;
}

int c2_llp_reject(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
{
        struct c2_dev *c2dev;
        struct c2wr_cr_reject_req wr;
        struct c2_vq_req *vq_req;
        struct c2wr_cr_reject_rep *reply;
        int err;

        c2dev = to_c2dev(cm_id->device);

        /*
         * Allocate verbs request.
         */
        vq_req = vq_req_alloc(c2dev);
        if (!vq_req)
                return -ENOMEM;

        /*
         * Build the WR
         */
        c2_wr_set_id(&wr, CCWR_CR_REJECT);
        wr.hdr.context = (unsigned long) vq_req;
        wr.rnic_handle = c2dev->adapter_handle;
        wr.ep_handle = (u32) (unsigned long) cm_id->provider_data;

        /*
         * reference the request struct.  dereferenced in the int handler.
         */
        vq_req_get(c2dev, vq_req);

        /*
         * Send WR to adapter
         */
        err = vq_send_wr(c2dev, (union c2wr *) & wr);
        if (err) {
                vq_req_put(c2dev, vq_req);
                goto bail0;
        }

        /*
         * Wait for reply from adapter
         */
        err = vq_wait_for_reply(c2dev, vq_req);
        if (err)
                goto bail0;

        /*
         * Process reply
         */
        reply = (struct c2wr_cr_reject_rep *) (unsigned long)
                vq_req->reply_msg;
        if (!reply) {
                err = -ENOMEM;
                goto bail0;
        }
        err = c2_errno(reply);
        /*
         * free vq stuff
         */
        vq_repbuf_free(c2dev, reply);

 bail0:
        vq_req_free(c2dev, vq_req);
        return err;
}