// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
/* Copyright (C) 2015-2018 Netronome Systems, Inc. */

/*
 * nfp_resource.c
 * Author: Jakub Kicinski <jakub.kicinski@netronome.com>
 *         Jason McMullan <jason.mcmullan@netronome.com>
 */
#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/slab.h>

#include "crc32.h"
#include "nfp.h"
#include "nfp_cpp.h"
#include "nfp6000/nfp6000.h"

#define NFP_RESOURCE_TBL_TARGET         NFP_CPP_TARGET_MU
#define NFP_RESOURCE_TBL_BASE           0x8100000000ULL

/* NFP Resource Table self-identifier */
#define NFP_RESOURCE_TBL_NAME           "nfp.res"
#define NFP_RESOURCE_TBL_KEY            0x00000000 /* Special key for entry 0 */

#define NFP_RESOURCE_ENTRY_NAME_SZ      8

/**
 * struct nfp_resource_entry - Resource table entry
 * @mutex:      NFP CPP Lock
 * @mutex.owner:        NFP CPP Lock, interface owner
 * @mutex.key:          NFP CPP Lock, posix_crc32(name, 8)
 * @region:     Memory region descriptor
 * @region.name:        ASCII, zero padded name
 * @region.reserved:    padding
 * @region.cpp_action:  CPP Action
 * @region.cpp_token:   CPP Token
 * @region.cpp_target:  CPP Target ID
 * @region.page_offset: 256-byte page offset into target's CPP address
 * @region.page_size:   size, in 256-byte pages
 */
struct nfp_resource_entry {
        struct nfp_resource_entry_mutex {
                u32 owner;
                u32 key;
        } mutex;
        struct nfp_resource_entry_region {
                u8  name[NFP_RESOURCE_ENTRY_NAME_SZ];
                u8  reserved[5];
                u8  cpp_action;
                u8  cpp_token;
                u8  cpp_target;
                u32 page_offset;
                u32 page_size;
        } region;
};

#define NFP_RESOURCE_TBL_SIZE           4096
#define NFP_RESOURCE_TBL_ENTRIES        (NFP_RESOURCE_TBL_SIZE /        \
                                         sizeof(struct nfp_resource_entry))

struct nfp_resource {
        char name[NFP_RESOURCE_ENTRY_NAME_SZ + 1];
        u32 cpp_id;
        u64 addr;
        u64 size;
        struct nfp_cpp_mutex *mutex;
};

static int nfp_cpp_resource_find(struct nfp_cpp *cpp, struct nfp_resource *res)
{
        struct nfp_resource_entry entry;
        u32 cpp_id, key;
        int ret, i;

        cpp_id = NFP_CPP_ID(NFP_RESOURCE_TBL_TARGET, 3, 0);  /* Atomic read */

        /* Search for a matching entry */
        if (!strcmp(res->name, NFP_RESOURCE_TBL_NAME)) {
                nfp_err(cpp, "Grabbing device lock not supported\n");
                return -EOPNOTSUPP;
        }
        key = crc32_posix(res->name, NFP_RESOURCE_ENTRY_NAME_SZ);

        for (i = 0; i < NFP_RESOURCE_TBL_ENTRIES; i++) {
                u64 addr = NFP_RESOURCE_TBL_BASE +
                        sizeof(struct nfp_resource_entry) * i;

                ret = nfp_cpp_read(cpp, cpp_id, addr, &entry, sizeof(entry));
                if (ret != sizeof(entry))
                        return -EIO;

                if (entry.mutex.key != key)
                        continue;

                /* Found key! */
                res->mutex =
                        nfp_cpp_mutex_alloc(cpp,
                                            NFP_RESOURCE_TBL_TARGET, addr, key);
                res->cpp_id = NFP_CPP_ID(entry.region.cpp_target,
                                         entry.region.cpp_action,
                                         entry.region.cpp_token);
                res->addr = (u64)entry.region.page_offset << 8;
                res->size = (u64)entry.region.page_size << 8;

                return 0;
        }

        return -ENOENT;
}

static int
nfp_resource_try_acquire(struct nfp_cpp *cpp, struct nfp_resource *res,
                         struct nfp_cpp_mutex *dev_mutex)
{
        int err;

        if (nfp_cpp_mutex_lock(dev_mutex))
                return -EINVAL;

        err = nfp_cpp_resource_find(cpp, res);
        if (err)
                goto err_unlock_dev;

        err = nfp_cpp_mutex_trylock(res->mutex);
        if (err)
                goto err_res_mutex_free;

        nfp_cpp_mutex_unlock(dev_mutex);

        return 0;

err_res_mutex_free:
        nfp_cpp_mutex_free(res->mutex);
err_unlock_dev:
        nfp_cpp_mutex_unlock(dev_mutex);

        return err;
}

/**
 * nfp_resource_acquire() - Acquire a resource handle
 * @cpp:        NFP CPP handle
 * @name:       Name of the resource
 *
 * NOTE: This function locks the acquired resource
 *
 * Return: NFP Resource handle, or ERR_PTR()
 */
struct nfp_resource *
nfp_resource_acquire(struct nfp_cpp *cpp, const char *name)
{
        unsigned long warn_at = jiffies + NFP_MUTEX_WAIT_FIRST_WARN * HZ;
        unsigned long err_at = jiffies + NFP_MUTEX_WAIT_ERROR * HZ;
        struct nfp_cpp_mutex *dev_mutex;
        struct nfp_resource *res;
        int err;

        res = kzalloc(sizeof(*res), GFP_KERNEL);
        if (!res)
                return ERR_PTR(-ENOMEM);

        strncpy(res->name, name, NFP_RESOURCE_ENTRY_NAME_SZ);

        dev_mutex = nfp_cpp_mutex_alloc(cpp, NFP_RESOURCE_TBL_TARGET,
                                        NFP_RESOURCE_TBL_BASE,
                                        NFP_RESOURCE_TBL_KEY);
        if (!dev_mutex) {
                kfree(res);
                return ERR_PTR(-ENOMEM);
        }

        for (;;) {
                err = nfp_resource_try_acquire(cpp, res, dev_mutex);
                if (!err)
                        break;
                if (err != -EBUSY)
                        goto err_free;

                err = msleep_interruptible(1);
                if (err != 0) {
                        err = -ERESTARTSYS;
                        goto err_free;
                }

                if (time_is_before_eq_jiffies(warn_at)) {
                        warn_at = jiffies + NFP_MUTEX_WAIT_NEXT_WARN * HZ;
                        nfp_warn(cpp, "Warning: waiting for NFP resource %s\n",
                                 name);
                }
                if (time_is_before_eq_jiffies(err_at)) {
                        nfp_err(cpp, "Error: resource %s timed out\n", name);
                        err = -EBUSY;
                        goto err_free;
                }
        }

        nfp_cpp_mutex_free(dev_mutex);

        return res;

err_free:
        nfp_cpp_mutex_free(dev_mutex);
        kfree(res);
        return ERR_PTR(err);
}

/**
 * nfp_resource_release() - Release a NFP Resource handle
 * @res:        NFP Resource handle
 *
 * NOTE: This function implictly unlocks the resource handle
 */
void nfp_resource_release(struct nfp_resource *res)
{
        nfp_cpp_mutex_unlock(res->mutex);
        nfp_cpp_mutex_free(res->mutex);
        kfree(res);
}

/**
 * nfp_resource_wait() - Wait for resource to appear
 * @cpp:        NFP CPP handle
 * @name:       Name of the resource
 * @secs:       Number of seconds to wait
 *
 * Wait for resource to appear in the resource table, grab and release
 * its lock.  The wait is jiffies-based, don't expect fine granularity.
 *
 * Return: 0 on success, errno otherwise.
 */
int nfp_resource_wait(struct nfp_cpp *cpp, const char *name, unsigned int secs)
{
        unsigned long warn_at = jiffies + NFP_MUTEX_WAIT_FIRST_WARN * HZ;
        unsigned long err_at = jiffies + secs * HZ;
        struct nfp_resource *res;

        while (true) {
                res = nfp_resource_acquire(cpp, name);
                if (!IS_ERR(res)) {
                        nfp_resource_release(res);
                        return 0;
                }

                if (PTR_ERR(res) != -ENOENT) {
                        nfp_err(cpp, "error waiting for resource %s: %ld\n",
                                name, PTR_ERR(res));
                        return PTR_ERR(res);
                }
                if (time_is_before_eq_jiffies(err_at)) {
                        nfp_err(cpp, "timeout waiting for resource %s\n", name);
                        return -ETIMEDOUT;
                }
                if (time_is_before_eq_jiffies(warn_at)) {
                        warn_at = jiffies + NFP_MUTEX_WAIT_NEXT_WARN * HZ;
                        nfp_info(cpp, "waiting for NFP resource %s\n", name);
                }
                if (msleep_interruptible(10)) {
                        nfp_err(cpp, "wait for resource %s interrupted\n",
                                name);
                        return -ERESTARTSYS;
                }
        }
}

/**
 * nfp_resource_cpp_id() - Return the cpp_id of a resource handle
 * @res:        NFP Resource handle
 *
 * Return: NFP CPP ID
 */
u32 nfp_resource_cpp_id(struct nfp_resource *res)
{
        return res->cpp_id;
}

/**
 * nfp_resource_name() - Return the name of a resource handle
 * @res:        NFP Resource handle
 *
 * Return: const char pointer to the name of the resource
 */
const char *nfp_resource_name(struct nfp_resource *res)
{
        return res->name;
}

/**
 * nfp_resource_address() - Return the address of a resource handle
 * @res:        NFP Resource handle
 *
 * Return: Address of the resource
 */
u64 nfp_resource_address(struct nfp_resource *res)
{
        return res->addr;
}

/**
 * nfp_resource_size() - Return the size in bytes of a resource handle
 * @res:        NFP Resource handle
 *
 * Return: Size of the resource in bytes
 */
u64 nfp_resource_size(struct nfp_resource *res)
{
        return res->size;
}

/**
 * nfp_resource_table_init() - Run initial checks on the resource table
 * @cpp:        NFP CPP handle
 *
 * Start-of-day init procedure for resource table.  Must be called before
 * any local resource table users may exist.
 *
 * Return: 0 on success, -errno on failure
 */
int nfp_resource_table_init(struct nfp_cpp *cpp)
{
        struct nfp_cpp_mutex *dev_mutex;
        int i, err;

        err = nfp_cpp_mutex_reclaim(cpp, NFP_RESOURCE_TBL_TARGET,
                                    NFP_RESOURCE_TBL_BASE);
        if (err < 0) {
                nfp_err(cpp, "Error: failed to reclaim resource table mutex\n");
                return err;
        }
        if (err)
                nfp_warn(cpp, "Warning: busted main resource table mutex\n");

        dev_mutex = nfp_cpp_mutex_alloc(cpp, NFP_RESOURCE_TBL_TARGET,
                                        NFP_RESOURCE_TBL_BASE,
                                        NFP_RESOURCE_TBL_KEY);
        if (!dev_mutex)
                return -ENOMEM;

        if (nfp_cpp_mutex_lock(dev_mutex)) {
                nfp_err(cpp, "Error: failed to claim resource table mutex\n");
                nfp_cpp_mutex_free(dev_mutex);
                return -EINVAL;
        }

        /* Resource 0 is the dev_mutex, start from 1 */
        for (i = 1; i < NFP_RESOURCE_TBL_ENTRIES; i++) {
                u64 addr = NFP_RESOURCE_TBL_BASE +
                        sizeof(struct nfp_resource_entry) * i;

                err = nfp_cpp_mutex_reclaim(cpp, NFP_RESOURCE_TBL_TARGET, addr);
                if (err < 0) {
                        nfp_err(cpp,
                                "Error: failed to reclaim resource %d mutex\n",
                                i);
                        goto err_unlock;
                }
                if (err)
                        nfp_warn(cpp, "Warning: busted resource %d mutex\n", i);
        }

        err = 0;
err_unlock:
        nfp_cpp_mutex_unlock(dev_mutex);
        nfp_cpp_mutex_free(dev_mutex);

        return err;
}