#if 1
/*
 * Copyright (c) 2020 The Linux Foundation. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software for
 * any purpose with or without fee is hereby granted, provided that the
 * above copyright notice and this permission notice appear in all
 * copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

/**
 * DOC: qdf_api.c
 * This file provides OS dependent deferred API's.
 */

#include <linux/kernel.h>
#include <linux/version.h>
#include <linux/module.h>
#include <linux/workqueue.h>
#include "qdf_module.h"
#include "qdf_defer.h"
#include "qdf_hrtimer.h"
#include "qdf_time.h"
#include "qdf_nbuf.h"
#include "qdf_mem.h"

void qdf_flush_work(qdf_handle_t hdl, qdf_work_t *work)
{
	__qdf_flush_work(hdl, work);
}
qdf_export_symbol(qdf_flush_work);

qdf_ktime_t qdf_hrtimer_get_remaining(qdf_hrtimer_data_t *timer)
{
	return __qdf_hrtimer_get_remaining(timer);
}
qdf_export_symbol(qdf_hrtimer_get_remaining);

void qdf_hrtimer_start(qdf_hrtimer_data_t *timer, qdf_ktime_t interval,
                       enum qdf_hrtimer_mode mode)
{
        __qdf_hrtimer_start(timer, interval, mode);
}
qdf_export_symbol(qdf_hrtimer_start);

qdf_ktime_t qdf_ktime_get(void)
{
        return __qdf_ktime_get();
}
qdf_export_symbol(qdf_ktime_get);

void qdf_hrtimer_cancel(qdf_hrtimer_data_t *timer)
{
        __qdf_hrtimer_cancel(timer);
}
qdf_export_symbol(qdf_hrtimer_cancel);

void qdf_hrtimer_kill(__qdf_hrtimer_data_t *timer)
{
         __qdf_hrtimer_kill(timer);
}
qdf_export_symbol(qdf_hrtimer_kill);

uint64_t qdf_hrtimer_forward(qdf_hrtimer_data_t *timer,
                                           qdf_ktime_t now,
                                           qdf_ktime_t interval)
{
        return __qdf_hrtimer_forward(timer, now, interval);
}
qdf_export_symbol(qdf_hrtimer_forward);

bool qdf_hrtimer_active(qdf_hrtimer_data_t *timer)
{
        return __qdf_hrtimer_active(timer);
}
qdf_export_symbol(qdf_hrtimer_active);

void qdf_hrtimer_init(qdf_hrtimer_data_t *timer,
                                    qdf_hrtimer_func_t callback,
                                    enum qdf_clock_id clock,
                                    enum qdf_hrtimer_mode mode,
                                    enum qdf_context_mode ctx)
{
        __qdf_hrtimer_init(timer, callback, clock, mode, ctx);
}
qdf_export_symbol(qdf_hrtimer_init);

bool qdf_cancel_work(qdf_handle_t hdl,
                                   qdf_work_t *work)
{
        return __qdf_cancel_work(hdl, work);
}
qdf_export_symbol(qdf_cancel_work);

uint32_t qdf_disable_work(qdf_handle_t hdl, qdf_work_t *work)
{
        return __qdf_disable_work(hdl, work);
}
qdf_export_symbol(qdf_disable_work);

void qdf_destroy_work(qdf_handle_t hdl, qdf_work_t *work)
{
        __qdf_disable_work(hdl, work);
}
qdf_export_symbol(qdf_destroy_work);

void qdf_destroy_workqueue(qdf_handle_t hdl,qdf_workqueue_t *wqueue)
{
        __qdf_destroy_workqueue(hdl, wqueue);
}
qdf_export_symbol(qdf_destroy_workqueue);


#if LINUX_VERSION_CODE  >= KERNEL_VERSION(3, 3, 0)
int qdf_clk_prepare_enable(struct clk *clk_t)
{
        return __qdf_clk_prepare_enable(clk_t);
}
qdf_export_symbol(qdf_clk_prepare_enable);

void qdf_clk_disable_unprepare (struct clk *clk_t)
{
        __qdf_clk_disable_unprepare(clk_t);
}
qdf_export_symbol(qdf_clk_disable_unprepare);
#endif

qdf_ktime_t qdf_ktime_get_real(void)
{
        return __qdf_ktime_get_real();
}
qdf_export_symbol(qdf_ktime_get_real);

uint64_t qdf_get_monotonic_boottime(void)
{
        return __qdf_get_monotonic_boottime();
}
qdf_export_symbol(qdf_get_monotonic_boottime);

void qdf_net_timestamp(struct sk_buff *skb)
{
        __qdf_net_timestamp(skb);
}
qdf_export_symbol(qdf_net_timestamp);

ktime_t qdf_net_timedelta(ktime_t t)
{
        return __qdf_net_timedelta(t);
}
qdf_export_symbol(qdf_net_timedelta);

qdf_workqueue_t *qdf_create_workqueue(char *name)
{
        return  __qdf_create_workqueue(name);
}
qdf_export_symbol(qdf_create_workqueue);


#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 1, 0)
int32_t qdf_of_property_read_u32_array(const struct device_node *np,
                                                     char *propname,
                                                     uint32_t *out_values,
                                                     qdf_size_t sz)
{
        return __qdf_of_property_read_u32_array(np, propname, out_values, sz);
}
qdf_export_symbol(qdf_of_property_read_u32_array);

int32_t  qdf_of_property_read_u32(const struct device_node *np,
                                       const char *propname,
                                       uint32_t *out_value)
{
        return __qdf_of_property_read_u32(np, propname, out_value);
}
qdf_export_symbol(qdf_of_property_read_u32);
#endif

void qdf_ktime_get_ts(struct timespec *ts)
{
        __qdf_ktime_get_ts(ts);
}
qdf_export_symbol(qdf_ktime_get_ts);


#if ((LINUX_VERSION_CODE  >= KERNEL_VERSION(3, 10, 0) && defined(CONFIG_RESET_CONTROLLER)) || \
     (LINUX_VERSION_CODE  >= KERNEL_VERSION(4, 5, 0)))
struct reset_control *qdf_reset_control_get(struct device *dev, const char *id)
{
        return __qdf_reset_control_get(dev, id);
}
qdf_export_symbol(qdf_reset_control_get);

int qdf_reset_control_deassert(struct reset_control *rstc)
{
        return __qdf_reset_control_deassert(rstc);
}
qdf_export_symbol(qdf_reset_control_deassert);

void qdf_reset_control_put(struct reset_control *rstc)
{
         __qdf_reset_control_put(rstc);
}
qdf_export_symbol(qdf_reset_control_put);

int qdf_reset_control_assert(struct reset_control *rstc)
{
        return __qdf_reset_control_assert(rstc);
}
qdf_export_symbol(qdf_reset_control_assert);
#endif


int qdf_gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
{
        return __qdf_gpio_request_one(gpio, flags, label);
}
qdf_export_symbol(qdf_gpio_request_one);

void qdf_gpio_free(unsigned gpio)
{
        __qdf_gpio_free(gpio);
}
qdf_export_symbol(qdf_gpio_free);

void qdf_init_dummy_netdev(struct net_device *netdev)
{
    __qdf_init_dummy_netdev(netdev);
}
qdf_export_symbol(qdf_init_dummy_netdev);

void qdf_gpio_set_value_cansleep(u_int8_t led_gpio, int on_or_off)
{
     __qdf_gpio_set_value_cansleep(led_gpio, on_or_off);
}
qdf_export_symbol(qdf_gpio_set_value_cansleep);

#endif


#if 1

#if LINUX_VERSION_CODE  >= KERNEL_VERSION(3, 1, 0)
struct property * qdf_of_find_property(const struct device_node *np,
                                                     const char *propname,
                                                     qdf_size_t *sz) {
	return of_find_property(np, propname, sz);
}
qdf_export_symbol(qdf_of_find_property);
#endif
#endif