/*
 * Intel MIC Platform Software Stack (MPSS)
 *
 * Copyright(c) 2015 Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2, as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * Intel SCIF driver.
 *
 */

#include "scif_main.h"

/**
 * scif_recv_mark: Handle SCIF_MARK request
 * @msg:        Interrupt message
 *
 * The peer has requested a mark.
 */
void scif_recv_mark(struct scif_dev *scifdev, struct scifmsg *msg)
{
        struct scif_endpt *ep = (struct scif_endpt *)msg->payload[0];
        int mark = 0;
        int err;

        err = _scif_fence_mark(ep, &mark);
        if (err)
                msg->uop = SCIF_MARK_NACK;
        else
                msg->uop = SCIF_MARK_ACK;
        msg->payload[0] = ep->remote_ep;
        msg->payload[2] = mark;
        scif_nodeqp_send(ep->remote_dev, msg);
}

/**
 * scif_recv_mark_resp: Handle SCIF_MARK_(N)ACK messages.
 * @msg:        Interrupt message
 *
 * The peer has responded to a SCIF_MARK message.
 */
void scif_recv_mark_resp(struct scif_dev *scifdev, struct scifmsg *msg)
{
        struct scif_endpt *ep = (struct scif_endpt *)msg->payload[0];
        struct scif_fence_info *fence_req =
                (struct scif_fence_info *)msg->payload[1];

        mutex_lock(&ep->rma_info.rma_lock);
        if (msg->uop == SCIF_MARK_ACK) {
                fence_req->state = OP_COMPLETED;
                fence_req->dma_mark = (int)msg->payload[2];
        } else {
                fence_req->state = OP_FAILED;
        }
        mutex_unlock(&ep->rma_info.rma_lock);
        complete(&fence_req->comp);
}

/**
 * scif_recv_wait: Handle SCIF_WAIT request
 * @msg:        Interrupt message
 *
 * The peer has requested waiting on a fence.
 */
void scif_recv_wait(struct scif_dev *scifdev, struct scifmsg *msg)
{
        struct scif_endpt *ep = (struct scif_endpt *)msg->payload[0];
        struct scif_remote_fence_info *fence;

        /*
         * Allocate structure for remote fence information and
         * send a NACK if the allocation failed. The peer will
         * return ENOMEM upon receiving a NACK.
         */
        fence = kmalloc(sizeof(*fence), GFP_KERNEL);
        if (!fence) {
                msg->payload[0] = ep->remote_ep;
                msg->uop = SCIF_WAIT_NACK;
                scif_nodeqp_send(ep->remote_dev, msg);
                return;
        }

        /* Prepare the fence request */
        memcpy(&fence->msg, msg, sizeof(struct scifmsg));
        INIT_LIST_HEAD(&fence->list);

        /* Insert to the global remote fence request list */
        mutex_lock(&scif_info.fencelock);
        atomic_inc(&ep->rma_info.fence_refcount);
        list_add_tail(&fence->list, &scif_info.fence);
        mutex_unlock(&scif_info.fencelock);

        schedule_work(&scif_info.misc_work);
}

/**
 * scif_recv_wait_resp: Handle SCIF_WAIT_(N)ACK messages.
 * @msg:        Interrupt message
 *
 * The peer has responded to a SCIF_WAIT message.
 */
void scif_recv_wait_resp(struct scif_dev *scifdev, struct scifmsg *msg)
{
        struct scif_endpt *ep = (struct scif_endpt *)msg->payload[0];
        struct scif_fence_info *fence_req =
                (struct scif_fence_info *)msg->payload[1];

        mutex_lock(&ep->rma_info.rma_lock);
        if (msg->uop == SCIF_WAIT_ACK)
                fence_req->state = OP_COMPLETED;
        else
                fence_req->state = OP_FAILED;
        mutex_unlock(&ep->rma_info.rma_lock);
        complete(&fence_req->comp);
}

/**
 * scif_recv_sig_local: Handle SCIF_SIG_LOCAL request
 * @msg:        Interrupt message
 *
 * The peer has requested a signal on a local offset.
 */
void scif_recv_sig_local(struct scif_dev *scifdev, struct scifmsg *msg)
{
        struct scif_endpt *ep = (struct scif_endpt *)msg->payload[0];
        int err;

        err = scif_prog_signal(ep, msg->payload[1], msg->payload[2],
                               SCIF_WINDOW_SELF);
        if (err)
                msg->uop = SCIF_SIG_NACK;
        else
                msg->uop = SCIF_SIG_ACK;
        msg->payload[0] = ep->remote_ep;
        scif_nodeqp_send(ep->remote_dev, msg);
}

/**
 * scif_recv_sig_remote: Handle SCIF_SIGNAL_REMOTE request
 * @msg:        Interrupt message
 *
 * The peer has requested a signal on a remote offset.
 */
void scif_recv_sig_remote(struct scif_dev *scifdev, struct scifmsg *msg)
{
        struct scif_endpt *ep = (struct scif_endpt *)msg->payload[0];
        int err;

        err = scif_prog_signal(ep, msg->payload[1], msg->payload[2],
                               SCIF_WINDOW_PEER);
        if (err)
                msg->uop = SCIF_SIG_NACK;
        else
                msg->uop = SCIF_SIG_ACK;
        msg->payload[0] = ep->remote_ep;
        scif_nodeqp_send(ep->remote_dev, msg);
}

/**
 * scif_recv_sig_resp: Handle SCIF_SIG_(N)ACK messages.
 * @msg:        Interrupt message
 *
 * The peer has responded to a signal request.
 */
void scif_recv_sig_resp(struct scif_dev *scifdev, struct scifmsg *msg)
{
        struct scif_endpt *ep = (struct scif_endpt *)msg->payload[0];
        struct scif_fence_info *fence_req =
                (struct scif_fence_info *)msg->payload[3];

        mutex_lock(&ep->rma_info.rma_lock);
        if (msg->uop == SCIF_SIG_ACK)
                fence_req->state = OP_COMPLETED;
        else
                fence_req->state = OP_FAILED;
        mutex_unlock(&ep->rma_info.rma_lock);
        complete(&fence_req->comp);
}

static inline void *scif_get_local_va(off_t off, struct scif_window *window)
{
        struct page **pages = window->pinned_pages->pages;
        int page_nr = (off - window->offset) >> PAGE_SHIFT;
        off_t page_off = off & ~PAGE_MASK;

        return page_address(pages[page_nr]) + page_off;
}

static void scif_prog_signal_cb(void *arg)
{
        struct scif_status *status = arg;

        dma_pool_free(status->ep->remote_dev->signal_pool, status,
                      status->src_dma_addr);
}

static int _scif_prog_signal(scif_epd_t epd, dma_addr_t dst, u64 val)
{
        struct scif_endpt *ep = (struct scif_endpt *)epd;
        struct dma_chan *chan = ep->rma_info.dma_chan;
        struct dma_device *ddev = chan->device;
        bool x100 = !is_dma_copy_aligned(chan->device, 1, 1, 1);
        struct dma_async_tx_descriptor *tx;
        struct scif_status *status = NULL;
        dma_addr_t src;
        dma_cookie_t cookie;
        int err;

        tx = ddev->device_prep_dma_memcpy(chan, 0, 0, 0, DMA_PREP_FENCE);
        if (!tx) {
                err = -ENOMEM;
                dev_err(&ep->remote_dev->sdev->dev, "%s %d err %d\n",
                        __func__, __LINE__, err);
                goto alloc_fail;
        }
        cookie = tx->tx_submit(tx);
        if (dma_submit_error(cookie)) {
                err = (int)cookie;
                dev_err(&ep->remote_dev->sdev->dev, "%s %d err %d\n",
                        __func__, __LINE__, err);
                goto alloc_fail;
        }
        dma_async_issue_pending(chan);
        if (x100) {
                /*
                 * For X100 use the status descriptor to write the value to
                 * the destination.
                 */
                tx = ddev->device_prep_dma_imm_data(chan, dst, val, 0);
        } else {
                status = dma_pool_alloc(ep->remote_dev->signal_pool, GFP_KERNEL,
                                        &src);
                if (!status) {
                        err = -ENOMEM;
                        dev_err(&ep->remote_dev->sdev->dev, "%s %d err %d\n",
                                __func__, __LINE__, err);
                        goto alloc_fail;
                }
                status->val = val;
                status->src_dma_addr = src;
                status->ep = ep;
                src += offsetof(struct scif_status, val);
                tx = ddev->device_prep_dma_memcpy(chan, dst, src, sizeof(val),
                                                  DMA_PREP_INTERRUPT);
        }
        if (!tx) {
                err = -ENOMEM;
                dev_err(&ep->remote_dev->sdev->dev, "%s %d err %d\n",
                        __func__, __LINE__, err);
                goto dma_fail;
        }
        if (!x100) {
                tx->callback = scif_prog_signal_cb;
                tx->callback_param = status;
        }
        cookie = tx->tx_submit(tx);
        if (dma_submit_error(cookie)) {
                err = -EIO;
                dev_err(&ep->remote_dev->sdev->dev, "%s %d err %d\n",
                        __func__, __LINE__, err);
                goto dma_fail;
        }
        dma_async_issue_pending(chan);
        return 0;
dma_fail:
        if (!x100)
                dma_pool_free(ep->remote_dev->signal_pool, status,
                              status->src_dma_addr);
alloc_fail:
        return err;
}

/*
 * scif_prog_signal:
 * @epd - Endpoint Descriptor
 * @offset - registered address to write @val to
 * @val - Value to be written at @offset
 * @type - Type of the window.
 *
 * Arrange to write a value to the registered offset after ensuring that the
 * offset provided is indeed valid.
 */
int scif_prog_signal(scif_epd_t epd, off_t offset, u64 val,
                     enum scif_window_type type)
{
        struct scif_endpt *ep = (struct scif_endpt *)epd;
        struct scif_window *window = NULL;
        struct scif_rma_req req;
        dma_addr_t dst_dma_addr;
        int err;

        mutex_lock(&ep->rma_info.rma_lock);
        req.out_window = &window;
        req.offset = offset;
        req.nr_bytes = sizeof(u64);
        req.prot = SCIF_PROT_WRITE;
        req.type = SCIF_WINDOW_SINGLE;
        if (type == SCIF_WINDOW_SELF)
                req.head = &ep->rma_info.reg_list;
        else
                req.head = &ep->rma_info.remote_reg_list;
        /* Does a valid window exist? */
        err = scif_query_window(&req);
        if (err) {
                dev_err(scif_info.mdev.this_device,
                        "%s %d err %d\n", __func__, __LINE__, err);
                goto unlock_ret;
        }

        if (scif_is_mgmt_node() && scifdev_self(ep->remote_dev)) {
                u64 *dst_virt;

                if (type == SCIF_WINDOW_SELF)
                        dst_virt = scif_get_local_va(offset, window);
                else
                        dst_virt =
                        scif_get_local_va(offset, (struct scif_window *)
                                          window->peer_window);
                *dst_virt = val;
        } else {
                dst_dma_addr = __scif_off_to_dma_addr(window, offset);
                err = _scif_prog_signal(epd, dst_dma_addr, val);
        }
unlock_ret:
        mutex_unlock(&ep->rma_info.rma_lock);
        return err;
}

static int _scif_fence_wait(scif_epd_t epd, int mark)
{
        struct scif_endpt *ep = (struct scif_endpt *)epd;
        dma_cookie_t cookie = mark & ~SCIF_REMOTE_FENCE;
        int err;

        /* Wait for DMA callback in scif_fence_mark_cb(..) */
        err = wait_event_interruptible_timeout(ep->rma_info.markwq,
                                               dma_async_is_tx_complete(
                                               ep->rma_info.dma_chan,
                                               cookie, NULL, NULL) ==
                                               DMA_COMPLETE,
                                               SCIF_NODE_ALIVE_TIMEOUT);
        if (!err)
                err = -ETIMEDOUT;
        else if (err > 0)
                err = 0;
        return err;
}

/**
 * scif_rma_handle_remote_fences:
 *
 * This routine services remote fence requests.
 */
void scif_rma_handle_remote_fences(void)
{
        struct list_head *item, *tmp;
        struct scif_remote_fence_info *fence;
        struct scif_endpt *ep;
        int mark, err;

        might_sleep();
        mutex_lock(&scif_info.fencelock);
        list_for_each_safe(item, tmp, &scif_info.fence) {
                fence = list_entry(item, struct scif_remote_fence_info,
                                   list);
                /* Remove fence from global list */
                list_del(&fence->list);

                /* Initiate the fence operation */
                ep = (struct scif_endpt *)fence->msg.payload[0];
                mark = fence->msg.payload[2];
                err = _scif_fence_wait(ep, mark);
                if (err)
                        fence->msg.uop = SCIF_WAIT_NACK;
                else
                        fence->msg.uop = SCIF_WAIT_ACK;
                fence->msg.payload[0] = ep->remote_ep;
                scif_nodeqp_send(ep->remote_dev, &fence->msg);
                kfree(fence);
                if (!atomic_sub_return(1, &ep->rma_info.fence_refcount))
                        schedule_work(&scif_info.misc_work);
        }
        mutex_unlock(&scif_info.fencelock);
}

static int _scif_send_fence(scif_epd_t epd, int uop, int mark, int *out_mark)
{
        int err;
        struct scifmsg msg;
        struct scif_fence_info *fence_req;
        struct scif_endpt *ep = (struct scif_endpt *)epd;

        fence_req = kmalloc(sizeof(*fence_req), GFP_KERNEL);
        if (!fence_req) {
                err = -ENOMEM;
                goto error;
        }

        fence_req->state = OP_IN_PROGRESS;
        init_completion(&fence_req->comp);

        msg.src = ep->port;
        msg.uop = uop;
        msg.payload[0] = ep->remote_ep;
        msg.payload[1] = (u64)fence_req;
        if (uop == SCIF_WAIT)
                msg.payload[2] = mark;
        spin_lock(&ep->lock);
        if (ep->state == SCIFEP_CONNECTED)
                err = scif_nodeqp_send(ep->remote_dev, &msg);
        else
                err = -ENOTCONN;
        spin_unlock(&ep->lock);
        if (err)
                goto error_free;
retry:
        /* Wait for a SCIF_WAIT_(N)ACK message */
        err = wait_for_completion_timeout(&fence_req->comp,
                                          SCIF_NODE_ALIVE_TIMEOUT);
        if (!err && scifdev_alive(ep))
                goto retry;
        if (!err)
                err = -ENODEV;
        if (err > 0)
                err = 0;
        mutex_lock(&ep->rma_info.rma_lock);
        if (err < 0) {
                if (fence_req->state == OP_IN_PROGRESS)
                        fence_req->state = OP_FAILED;
        }
        if (fence_req->state == OP_FAILED && !err)
                err = -ENOMEM;
        if (uop == SCIF_MARK && fence_req->state == OP_COMPLETED)
                *out_mark = SCIF_REMOTE_FENCE | fence_req->dma_mark;
        mutex_unlock(&ep->rma_info.rma_lock);
error_free:
        kfree(fence_req);
error:
        return err;
}

/**
 * scif_send_fence_mark:
 * @epd: end point descriptor.
 * @out_mark: Output DMA mark reported by peer.
 *
 * Send a remote fence mark request.
 */
static int scif_send_fence_mark(scif_epd_t epd, int *out_mark)
{
        return _scif_send_fence(epd, SCIF_MARK, 0, out_mark);
}

/**
 * scif_send_fence_wait:
 * @epd: end point descriptor.
 * @mark: DMA mark to wait for.
 *
 * Send a remote fence wait request.
 */
static int scif_send_fence_wait(scif_epd_t epd, int mark)
{
        return _scif_send_fence(epd, SCIF_WAIT, mark, NULL);
}

static int _scif_send_fence_signal_wait(struct scif_endpt *ep,
                                        struct scif_fence_info *fence_req)
{
        int err;

retry:
        /* Wait for a SCIF_SIG_(N)ACK message */
        err = wait_for_completion_timeout(&fence_req->comp,
                                          SCIF_NODE_ALIVE_TIMEOUT);
        if (!err && scifdev_alive(ep))
                goto retry;
        if (!err)
                err = -ENODEV;
        if (err > 0)
                err = 0;
        if (err < 0) {
                mutex_lock(&ep->rma_info.rma_lock);
                if (fence_req->state == OP_IN_PROGRESS)
                        fence_req->state = OP_FAILED;
                mutex_unlock(&ep->rma_info.rma_lock);
        }
        if (fence_req->state == OP_FAILED && !err)
                err = -ENXIO;
        return err;
}

/**
 * scif_send_fence_signal:
 * @epd - endpoint descriptor
 * @loff - local offset
 * @lval - local value to write to loffset
 * @roff - remote offset
 * @rval - remote value to write to roffset
 * @flags - flags
 *
 * Sends a remote fence signal request
 */
static int scif_send_fence_signal(scif_epd_t epd, off_t roff, u64 rval,
                                  off_t loff, u64 lval, int flags)
{
        int err = 0;
        struct scifmsg msg;
        struct scif_fence_info *fence_req;
        struct scif_endpt *ep = (struct scif_endpt *)epd;

        fence_req = kmalloc(sizeof(*fence_req), GFP_KERNEL);
        if (!fence_req) {
                err = -ENOMEM;
                goto error;
        }

        fence_req->state = OP_IN_PROGRESS;
        init_completion(&fence_req->comp);
        msg.src = ep->port;
        if (flags & SCIF_SIGNAL_LOCAL) {
                msg.uop = SCIF_SIG_LOCAL;
                msg.payload[0] = ep->remote_ep;
                msg.payload[1] = roff;
                msg.payload[2] = rval;
                msg.payload[3] = (u64)fence_req;
                spin_lock(&ep->lock);
                if (ep->state == SCIFEP_CONNECTED)
                        err = scif_nodeqp_send(ep->remote_dev, &msg);
                else
                        err = -ENOTCONN;
                spin_unlock(&ep->lock);
                if (err)
                        goto error_free;
                err = _scif_send_fence_signal_wait(ep, fence_req);
                if (err)
                        goto error_free;
        }
        fence_req->state = OP_IN_PROGRESS;

        if (flags & SCIF_SIGNAL_REMOTE) {
                msg.uop = SCIF_SIG_REMOTE;
                msg.payload[0] = ep->remote_ep;
                msg.payload[1] = loff;
                msg.payload[2] = lval;
                msg.payload[3] = (u64)fence_req;
                spin_lock(&ep->lock);
                if (ep->state == SCIFEP_CONNECTED)
                        err = scif_nodeqp_send(ep->remote_dev, &msg);
                else
                        err = -ENOTCONN;
                spin_unlock(&ep->lock);
                if (err)
                        goto error_free;
                err = _scif_send_fence_signal_wait(ep, fence_req);
        }
error_free:
        kfree(fence_req);
error:
        return err;
}

static void scif_fence_mark_cb(void *arg)
{
        struct scif_endpt *ep = (struct scif_endpt *)arg;

        wake_up_interruptible(&ep->rma_info.markwq);
        atomic_dec(&ep->rma_info.fence_refcount);
}

/*
 * _scif_fence_mark:
 *
 * @epd - endpoint descriptor
 * Set up a mark for this endpoint and return the value of the mark.
 */
int _scif_fence_mark(scif_epd_t epd, int *mark)
{
        struct scif_endpt *ep = (struct scif_endpt *)epd;
        struct dma_chan *chan = ep->rma_info.dma_chan;
        struct dma_device *ddev = chan->device;
        struct dma_async_tx_descriptor *tx;
        dma_cookie_t cookie;
        int err;

        tx = ddev->device_prep_dma_memcpy(chan, 0, 0, 0, DMA_PREP_FENCE);
        if (!tx) {
                err = -ENOMEM;
                dev_err(&ep->remote_dev->sdev->dev, "%s %d err %d\n",
                        __func__, __LINE__, err);
                return err;
        }
        cookie = tx->tx_submit(tx);
        if (dma_submit_error(cookie)) {
                err = (int)cookie;
                dev_err(&ep->remote_dev->sdev->dev, "%s %d err %d\n",
                        __func__, __LINE__, err);
                return err;
        }
        dma_async_issue_pending(chan);
        tx = ddev->device_prep_dma_interrupt(chan, DMA_PREP_INTERRUPT);
        if (!tx) {
                err = -ENOMEM;
                dev_err(&ep->remote_dev->sdev->dev, "%s %d err %d\n",
                        __func__, __LINE__, err);
                return err;
        }
        tx->callback = scif_fence_mark_cb;
        tx->callback_param = ep;
        *mark = cookie = tx->tx_submit(tx);
        if (dma_submit_error(cookie)) {
                err = (int)cookie;
                dev_err(&ep->remote_dev->sdev->dev, "%s %d err %d\n",
                        __func__, __LINE__, err);
                return err;
        }
        atomic_inc(&ep->rma_info.fence_refcount);
        dma_async_issue_pending(chan);
        return 0;
}

#define SCIF_LOOPB_MAGIC_MARK 0xdead

int scif_fence_mark(scif_epd_t epd, int flags, int *mark)
{
        struct scif_endpt *ep = (struct scif_endpt *)epd;
        int err = 0;

        dev_dbg(scif_info.mdev.this_device,
                "SCIFAPI fence_mark: ep %p flags 0x%x mark 0x%x\n",
                ep, flags, *mark);
        err = scif_verify_epd(ep);
        if (err)
                return err;

        /* Invalid flags? */
        if (flags & ~(SCIF_FENCE_INIT_SELF | SCIF_FENCE_INIT_PEER))
                return -EINVAL;

        /* At least one of init self or peer RMA should be set */
        if (!(flags & (SCIF_FENCE_INIT_SELF | SCIF_FENCE_INIT_PEER)))
                return -EINVAL;

        /* Exactly one of init self or peer RMA should be set but not both */
        if ((flags & SCIF_FENCE_INIT_SELF) && (flags & SCIF_FENCE_INIT_PEER))
                return -EINVAL;

        /*
         * Management node loopback does not need to use DMA.
         * Return a valid mark to be symmetric.
         */
        if (scifdev_self(ep->remote_dev) && scif_is_mgmt_node()) {
                *mark = SCIF_LOOPB_MAGIC_MARK;
                return 0;
        }

        if (flags & SCIF_FENCE_INIT_SELF)
                err = _scif_fence_mark(epd, mark);
        else
                err = scif_send_fence_mark(ep, mark);

        if (err)
                dev_err(scif_info.mdev.this_device,
                        "%s %d err %d\n", __func__, __LINE__, err);
        dev_dbg(scif_info.mdev.this_device,
                "SCIFAPI fence_mark: ep %p flags 0x%x mark 0x%x err %d\n",
                ep, flags, *mark, err);
        return err;
}
EXPORT_SYMBOL_GPL(scif_fence_mark);

int scif_fence_wait(scif_epd_t epd, int mark)
{
        struct scif_endpt *ep = (struct scif_endpt *)epd;
        int err = 0;

        dev_dbg(scif_info.mdev.this_device,
                "SCIFAPI fence_wait: ep %p mark 0x%x\n",
                ep, mark);
        err = scif_verify_epd(ep);
        if (err)
                return err;
        /*
         * Management node loopback does not need to use DMA.
         * The only valid mark provided is 0 so simply
         * return success if the mark is valid.
         */
        if (scifdev_self(ep->remote_dev) && scif_is_mgmt_node()) {
                if (mark == SCIF_LOOPB_MAGIC_MARK)
                        return 0;
                else
                        return -EINVAL;
        }
        if (mark & SCIF_REMOTE_FENCE)
                err = scif_send_fence_wait(epd, mark);
        else
                err = _scif_fence_wait(epd, mark);
        if (err < 0)
                dev_err(scif_info.mdev.this_device,
                        "%s %d err %d\n", __func__, __LINE__, err);
        return err;
}
EXPORT_SYMBOL_GPL(scif_fence_wait);

int scif_fence_signal(scif_epd_t epd, off_t loff, u64 lval,
                      off_t roff, u64 rval, int flags)
{
        struct scif_endpt *ep = (struct scif_endpt *)epd;
        int err = 0;

        dev_dbg(scif_info.mdev.this_device,
                "SCIFAPI fence_signal: ep %p loff 0x%lx lval 0x%llx roff 0x%lx rval 0x%llx flags 0x%x\n",
                ep, loff, lval, roff, rval, flags);
        err = scif_verify_epd(ep);
        if (err)
                return err;

        /* Invalid flags? */
        if (flags & ~(SCIF_FENCE_INIT_SELF | SCIF_FENCE_INIT_PEER |
                        SCIF_SIGNAL_LOCAL | SCIF_SIGNAL_REMOTE))
                return -EINVAL;

        /* At least one of init self or peer RMA should be set */
        if (!(flags & (SCIF_FENCE_INIT_SELF | SCIF_FENCE_INIT_PEER)))
                return -EINVAL;

        /* Exactly one of init self or peer RMA should be set but not both */
        if ((flags & SCIF_FENCE_INIT_SELF) && (flags & SCIF_FENCE_INIT_PEER))
                return -EINVAL;

        /* At least one of SCIF_SIGNAL_LOCAL or SCIF_SIGNAL_REMOTE required */
        if (!(flags & (SCIF_SIGNAL_LOCAL | SCIF_SIGNAL_REMOTE)))
                return -EINVAL;

        /* Only Dword offsets allowed */
        if ((flags & SCIF_SIGNAL_LOCAL) && (loff & (sizeof(u32) - 1)))
                return -EINVAL;

        /* Only Dword aligned offsets allowed */
        if ((flags & SCIF_SIGNAL_REMOTE) && (roff & (sizeof(u32) - 1)))
                return -EINVAL;

        if (flags & SCIF_FENCE_INIT_PEER) {
                err = scif_send_fence_signal(epd, roff, rval, loff,
                                             lval, flags);
        } else {
                /* Local Signal in Local RAS */
                if (flags & SCIF_SIGNAL_LOCAL) {
                        err = scif_prog_signal(epd, loff, lval,
                                               SCIF_WINDOW_SELF);
                        if (err)
                                goto error_ret;
                }

                /* Signal in Remote RAS */
                if (flags & SCIF_SIGNAL_REMOTE)
                        err = scif_prog_signal(epd, roff,
                                               rval, SCIF_WINDOW_PEER);
        }
error_ret:
        if (err)
                dev_err(scif_info.mdev.this_device,
                        "%s %d err %d\n", __func__, __LINE__, err);
        return err;
}
EXPORT_SYMBOL_GPL(scif_fence_signal);