// SPDX-License-Identifier: GPL-2.0
/*
 * Support for Medifield PNW Camera Imaging ISP subsystem.
 *
 * Copyright (c) 2010 Intel Corporation. All Rights Reserved.
 *
 * Copyright (c) 2010 Silicon Hive www.siliconhive.com.
 *
 * 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.
 *
 *
 */
/*
 * This file contains functions for reserved memory pool management
 */
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/mm.h>

#include <asm/set_memory.h>

#include "atomisp_internal.h"
#include "hmm/hmm_pool.h"

/*
 * reserved memory pool ops.
 */
static unsigned int get_pages_from_reserved_pool(void *pool,
        struct hmm_page_object *page_obj,
        unsigned int size, bool cached)
{
        unsigned long flags;
        unsigned int i = 0;
        unsigned int repool_pgnr;
        int j;
        struct hmm_reserved_pool_info *repool_info = pool;

        if (!repool_info)
                return 0;

        spin_lock_irqsave(&repool_info->list_lock, flags);
        if (repool_info->initialized) {
                repool_pgnr = repool_info->index;

                for (j = repool_pgnr - 1; j >= 0; j--) {
                        page_obj[i].page = repool_info->pages[j];
                        page_obj[i].type = HMM_PAGE_TYPE_RESERVED;
                        i++;
                        repool_info->index--;
                        if (i == size)
                                break;
                }
        }
        spin_unlock_irqrestore(&repool_info->list_lock, flags);
        return i;
}

static void free_pages_to_reserved_pool(void *pool,
                                        struct hmm_page_object *page_obj)
{
        unsigned long flags;
        struct hmm_reserved_pool_info *repool_info = pool;

        if (!repool_info)
                return;

        spin_lock_irqsave(&repool_info->list_lock, flags);

        if (repool_info->initialized &&
            repool_info->index < repool_info->pgnr &&
            page_obj->type == HMM_PAGE_TYPE_RESERVED) {
                repool_info->pages[repool_info->index++] = page_obj->page;
        }

        spin_unlock_irqrestore(&repool_info->list_lock, flags);
}

static int hmm_reserved_pool_setup(struct hmm_reserved_pool_info **repool_info,
                                   unsigned int pool_size)
{
        struct hmm_reserved_pool_info *pool_info;

        pool_info = kmalloc(sizeof(struct hmm_reserved_pool_info),
                            GFP_KERNEL);
        if (unlikely(!pool_info))
                return -ENOMEM;

        pool_info->pages = kmalloc(sizeof(struct page *) * pool_size,
                                   GFP_KERNEL);
        if (unlikely(!pool_info->pages)) {
                kfree(pool_info);
                return -ENOMEM;
        }

        pool_info->index = 0;
        pool_info->pgnr = 0;
        spin_lock_init(&pool_info->list_lock);
        pool_info->initialized = true;

        *repool_info = pool_info;

        return 0;
}

static int hmm_reserved_pool_init(void **pool, unsigned int pool_size)
{
        int ret;
        unsigned int blk_pgnr;
        unsigned int pgnr = pool_size;
        unsigned int order = 0;
        unsigned int i = 0;
        int fail_number = 0;
        struct page *pages;
        int j;
        struct hmm_reserved_pool_info *repool_info;

        if (pool_size == 0)
                return 0;

        ret = hmm_reserved_pool_setup(&repool_info, pool_size);
        if (ret) {
                dev_err(atomisp_dev, "hmm_reserved_pool_setup failed.\n");
                return ret;
        }

        pgnr = pool_size;

        i = 0;
        order = MAX_ORDER;

        while (pgnr) {
                blk_pgnr = 1U << order;
                while (blk_pgnr > pgnr) {
                        order--;
                        blk_pgnr >>= 1U;
                }
                BUG_ON(order > MAX_ORDER);

                pages = alloc_pages(GFP_KERNEL | __GFP_NOWARN, order);
                if (unlikely(!pages)) {
                        if (order == 0) {
                                fail_number++;
                                dev_err(atomisp_dev, "%s: alloc_pages failed: %d\n",
                                        __func__, fail_number);
                                /* if fail five times, will goto end */

                                /* FIXME: whether is the mechanism is ok? */
                                if (fail_number == ALLOC_PAGE_FAIL_NUM)
                                        goto end;
                        } else {
                                order--;
                        }
                } else {
                        blk_pgnr = 1U << order;

                        ret = set_pages_uc(pages, blk_pgnr);
                        if (ret) {
                                dev_err(atomisp_dev,
                                        "set pages uncached failed\n");
                                __free_pages(pages, order);
                                goto end;
                        }

                        for (j = 0; j < blk_pgnr; j++)
                                repool_info->pages[i++] = pages + j;

                        repool_info->index += blk_pgnr;
                        repool_info->pgnr += blk_pgnr;

                        pgnr -= blk_pgnr;

                        fail_number = 0;
                }
        }

end:
        repool_info->initialized = true;

        *pool = repool_info;

        dev_info(atomisp_dev,
                 "hmm_reserved_pool init successfully,hmm_reserved_pool is with %d pages.\n",
                 repool_info->pgnr);
        return 0;
}

static void hmm_reserved_pool_exit(void **pool)
{
        unsigned long flags;
        int i, ret;
        unsigned int pgnr;
        struct hmm_reserved_pool_info *repool_info = *pool;

        if (!repool_info)
                return;

        spin_lock_irqsave(&repool_info->list_lock, flags);
        if (!repool_info->initialized) {
                spin_unlock_irqrestore(&repool_info->list_lock, flags);
                return;
        }
        pgnr = repool_info->pgnr;
        repool_info->index = 0;
        repool_info->pgnr = 0;
        repool_info->initialized = false;
        spin_unlock_irqrestore(&repool_info->list_lock, flags);

        for (i = 0; i < pgnr; i++) {
                ret = set_pages_wb(repool_info->pages[i], 1);
                if (ret)
                        dev_err(atomisp_dev,
                                "set page to WB err...ret=%d\n", ret);
                /*
                W/A: set_pages_wb seldom return value = -EFAULT
                indicate that address of page is not in valid
                range(0xffff880000000000~0xffffc7ffffffffff)
                then, _free_pages would panic; Do not know why
                page address be valid, it maybe memory corruption by lowmemory
                */
                if (!ret)
                        __free_pages(repool_info->pages[i], 0);
        }

        kfree(repool_info->pages);
        kfree(repool_info);

        *pool = NULL;
}

static int hmm_reserved_pool_inited(void *pool)
{
        struct hmm_reserved_pool_info *repool_info = pool;

        if (!repool_info)
                return 0;

        return repool_info->initialized;
}

struct hmm_pool_ops reserved_pops = {
        .pool_init              = hmm_reserved_pool_init,
        .pool_exit              = hmm_reserved_pool_exit,
        .pool_alloc_pages       = get_pages_from_reserved_pool,
        .pool_free_pages        = free_pages_to_reserved_pool,
        .pool_inited            = hmm_reserved_pool_inited,
};