/* 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.
 *
 *
 */

#ifndef __HMM_BO_H__
#define __HMM_BO_H__

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/spinlock.h>
#include <linux/mutex.h>
#include "mmu/isp_mmu.h"
#include "hmm/hmm_common.h"
#include "ia_css_types.h"

#define check_bodev_null_return(bdev, exp)      \
                check_null_return(bdev, exp, \
                        "NULL hmm_bo_device.\n")

#define check_bodev_null_return_void(bdev)      \
                check_null_return_void(bdev, \
                        "NULL hmm_bo_device.\n")

#define check_bo_status_yes_goto(bo, _status, label) \
        var_not_equal_goto((bo->status & (_status)), (_status), \
                        label, \
                        "HMM buffer status not contain %s.\n", \
                        #_status)

#define check_bo_status_no_goto(bo, _status, label) \
        var_equal_goto((bo->status & (_status)), (_status), \
                        label, \
                        "HMM buffer status contains %s.\n", \
                        #_status)

#define rbtree_node_to_hmm_bo(root_node)        \
        container_of((root_node), struct hmm_buffer_object, node)

#define list_to_hmm_bo(list_ptr)        \
        list_entry((list_ptr), struct hmm_buffer_object, list)

#define kref_to_hmm_bo(kref_ptr)        \
        list_entry((kref_ptr), struct hmm_buffer_object, kref)

#define check_bo_null_return(bo, exp)   \
        check_null_return(bo, exp, "NULL hmm buffer object.\n")

#define check_bo_null_return_void(bo)   \
        check_null_return_void(bo, "NULL hmm buffer object.\n")

#define HMM_MAX_ORDER           3
#define HMM_MIN_ORDER           0

#define ISP_VM_START    0x0
#define ISP_VM_SIZE     (0x7FFFFFFF)    /* 2G address space */
#define ISP_PTR_NULL    NULL

#define HMM_BO_DEVICE_INITED    0x1

enum hmm_bo_type {
        HMM_BO_PRIVATE,
        HMM_BO_SHARE,
        HMM_BO_USER,
        HMM_BO_LAST,
};

enum hmm_page_type {
        HMM_PAGE_TYPE_RESERVED,
        HMM_PAGE_TYPE_DYNAMIC,
        HMM_PAGE_TYPE_GENERAL,
};

#define HMM_BO_MASK             0x1
#define HMM_BO_FREE             0x0
#define HMM_BO_ALLOCED  0x1
#define HMM_BO_PAGE_ALLOCED     0x2
#define HMM_BO_BINDED           0x4
#define HMM_BO_MMAPED           0x8
#define HMM_BO_VMAPED           0x10
#define HMM_BO_VMAPED_CACHED    0x20
#define HMM_BO_ACTIVE           0x1000
#define HMM_BO_MEM_TYPE_USER     0x1
#define HMM_BO_MEM_TYPE_PFN      0x2

struct hmm_bo_device {
        struct isp_mmu          mmu;

        /* start/pgnr/size is used to record the virtual memory of this bo */
        unsigned int start;
        unsigned int pgnr;
        unsigned int size;

        /* list lock is used to protect the entire_bo_list */
        spinlock_t      list_lock;
        int flag;

        /* linked list for entire buffer object */
        struct list_head entire_bo_list;
        /* rbtree for maintain entire allocated vm */
        struct rb_root allocated_rbtree;
        /* rbtree for maintain entire free vm */
        struct rb_root free_rbtree;
        struct mutex rbtree_mutex;
        struct kmem_cache *bo_cache;
};

struct hmm_page_object {
        struct page             *page;
        enum hmm_page_type      type;
};

struct hmm_buffer_object {
        struct hmm_bo_device    *bdev;
        struct list_head        list;
        struct kref     kref;

        struct page **pages;

        /* mutex protecting this BO */
        struct mutex            mutex;
        enum hmm_bo_type        type;
        struct hmm_page_object  *page_obj;      /* physical pages */
        int             from_highmem;
        int             mmap_count;
        int             status;
        int             mem_type;
        void            *vmap_addr; /* kernel virtual address by vmap */

        struct rb_node  node;
        unsigned int    start;
        unsigned int    end;
        unsigned int    pgnr;
        /*
         * When insert a bo which has the same pgnr with an existed
         * bo node in the free_rbtree, using "prev & next" pointer
         * to maintain a bo linked list instead of insert this bo
         * into free_rbtree directly, it will make sure each node
         * in free_rbtree has different pgnr.
         * "prev & next" default is NULL.
         */
        struct hmm_buffer_object        *prev;
        struct hmm_buffer_object        *next;
};

struct hmm_buffer_object *hmm_bo_alloc(struct hmm_bo_device *bdev,
                                       unsigned int pgnr);

void hmm_bo_release(struct hmm_buffer_object *bo);

int hmm_bo_device_init(struct hmm_bo_device *bdev,
                       struct isp_mmu_client *mmu_driver,
                       unsigned int vaddr_start, unsigned int size);

/*
 * clean up all hmm_bo_device related things.
 */
void hmm_bo_device_exit(struct hmm_bo_device *bdev);

/*
 * whether the bo device is inited or not.
 */
int hmm_bo_device_inited(struct hmm_bo_device *bdev);

/*
 * increse buffer object reference.
 */
void hmm_bo_ref(struct hmm_buffer_object *bo);

/*
 * decrese buffer object reference. if reference reaches 0,
 * release function of the buffer object will be called.
 *
 * this call is also used to release hmm_buffer_object or its
 * upper level object with it embedded in. you need to call
 * this function when it is no longer used.
 *
 * Note:
 *
 * user dont need to care about internal resource release of
 * the buffer object in the release callback, it will be
 * handled internally.
 *
 * this call will only release internal resource of the buffer
 * object but will not free the buffer object itself, as the
 * buffer object can be both pre-allocated statically or
 * dynamically allocated. so user need to deal with the release
 * of the buffer object itself manually. below example shows
 * the normal case of using the buffer object.
 *
 *      struct hmm_buffer_object *bo = hmm_bo_create(bdev, pgnr);
 *      ......
 *      hmm_bo_unref(bo);
 *
 * or:
 *
 *      struct hmm_buffer_object bo;
 *
 *      hmm_bo_init(bdev, &bo, pgnr, NULL);
 *      ...
 *      hmm_bo_unref(&bo);
 */
void hmm_bo_unref(struct hmm_buffer_object *bo);

/*
 * allocate/free physical pages for the bo. will try to alloc mem
 * from highmem if from_highmem is set, and type indicate that the
 * pages will be allocated by using video driver (for share buffer)
 * or by ISP driver itself.
 */

int hmm_bo_allocated(struct hmm_buffer_object *bo);

/*
 * allocate/free physical pages for the bo. will try to alloc mem
 * from highmem if from_highmem is set, and type indicate that the
 * pages will be allocated by using video driver (for share buffer)
 * or by ISP driver itself.
 */
int hmm_bo_alloc_pages(struct hmm_buffer_object *bo,
                       enum hmm_bo_type type, int from_highmem,
                       const void __user *userptr, bool cached);
void hmm_bo_free_pages(struct hmm_buffer_object *bo);
int hmm_bo_page_allocated(struct hmm_buffer_object *bo);

/*
 * get physical page info of the bo.
 */
int hmm_bo_get_page_info(struct hmm_buffer_object *bo,
                         struct hmm_page_object **page_obj, int *pgnr);

/*
 * bind/unbind the physical pages to a virtual address space.
 */
int hmm_bo_bind(struct hmm_buffer_object *bo);
void hmm_bo_unbind(struct hmm_buffer_object *bo);
int hmm_bo_binded(struct hmm_buffer_object *bo);

/*
 * vmap buffer object's pages to contiguous kernel virtual address.
 * if the buffer has been vmaped, return the virtual address directly.
 */
void *hmm_bo_vmap(struct hmm_buffer_object *bo, bool cached);

/*
 * flush the cache for the vmapped buffer object's pages,
 * if the buffer has not been vmapped, return directly.
 */
void hmm_bo_flush_vmap(struct hmm_buffer_object *bo);

/*
 * vunmap buffer object's kernel virtual address.
 */
void hmm_bo_vunmap(struct hmm_buffer_object *bo);

/*
 * mmap the bo's physical pages to specific vma.
 *
 * vma's address space size must be the same as bo's size,
 * otherwise it will return -EINVAL.
 *
 * vma->vm_flags will be set to (VM_RESERVED | VM_IO).
 */
int hmm_bo_mmap(struct vm_area_struct *vma,
                struct hmm_buffer_object *bo);

extern struct hmm_pool  dynamic_pool;
extern struct hmm_pool  reserved_pool;

/*
 * find the buffer object by its virtual address vaddr.
 * return NULL if no such buffer object found.
 */
struct hmm_buffer_object *hmm_bo_device_search_start(
    struct hmm_bo_device *bdev, ia_css_ptr vaddr);

/*
 * find the buffer object by its virtual address.
 * it does not need to be the start address of one bo,
 * it can be an address within the range of one bo.
 * return NULL if no such buffer object found.
 */
struct hmm_buffer_object *hmm_bo_device_search_in_range(
    struct hmm_bo_device *bdev, ia_css_ptr vaddr);

/*
 * find the buffer object with kernel virtual address vaddr.
 * return NULL if no such buffer object found.
 */
struct hmm_buffer_object *hmm_bo_device_search_vmap_start(
    struct hmm_bo_device *bdev, const void *vaddr);

#endif