// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 2007 - 2012 Realtek Corporation. */

#define _OSDEP_SERVICE_C_

#include "../include/osdep_service.h"
#include "../include/drv_types.h"
#include "../include/recv_osdep.h"
#include "../include/rtw_ioctl_set.h"

/*
* Translate the OS dependent @param error_code to OS independent RTW_STATUS_CODE
* @return: one of RTW_STATUS_CODE
*/
inline int RTW_STATUS_CODE(int error_code)
{
        if (error_code >= 0)
                return _SUCCESS;
        return _FAIL;
}

u32 rtw_atoi(u8 *s)
{
        int num = 0, flag = 0;
        int i;
        for (i = 0; i <= strlen(s); i++) {
                if (s[i] >= '0' && s[i] <= '9')
                        num = num * 10 + s[i] - '0';
                else if (s[0] == '-' && i == 0)
                        flag = 1;
                else
                        break;
        }
        if (flag == 1)
                num = num * -1;
        return num;
}

void *rtw_malloc2d(int h, int w, int size)
{
        int j;

        void **a = kzalloc(h * sizeof(void *) + h * w * size, GFP_KERNEL);
        if (!a)
                return NULL;

        for (j = 0; j < h; j++)
                a[j] = ((char *)(a + h)) + j * w * size;

        return a;
}

/*
For the following list_xxx operations,
caller must guarantee the atomic context.
Otherwise, there will be racing condition.
*/
/*
Caller must check if the list is empty before calling rtw_list_delete
*/

u32 _rtw_down_sema(struct semaphore *sema)
{
        if (down_interruptible(sema))
                return _FAIL;
        else
                return _SUCCESS;
}

void    _rtw_mutex_init(struct mutex *pmutex)
{
        mutex_init(pmutex);
}

void    _rtw_mutex_free(struct mutex *pmutex)
{
        mutex_destroy(pmutex);
}

void    _rtw_init_queue(struct __queue *pqueue)
{
        INIT_LIST_HEAD(&pqueue->queue);
        spin_lock_init(&pqueue->lock);
}

inline u32 rtw_systime_to_ms(u32 systime)
{
        return systime * 1000 / HZ;
}

inline u32 rtw_ms_to_systime(u32 ms)
{
        return ms * HZ / 1000;
}

/*  the input parameter start use the same unit as jiffies */
inline s32 rtw_get_passing_time_ms(u32 start)
{
        return rtw_systime_to_ms(jiffies - start);
}

void rtw_usleep_os(int us)
{
        if (1 < (us / 1000))
                msleep(1);
        else
                msleep((us / 1000) + 1);
}

#define RTW_SUSPEND_LOCK_NAME "rtw_wifi"

static const struct device_type wlan_type = {
        .name = "wlan",
};

struct net_device *rtw_alloc_etherdev_with_old_priv(int sizeof_priv,
                                                    void *old_priv)
{
        struct net_device *pnetdev;
        struct rtw_netdev_priv_indicator *pnpi;

        pnetdev = alloc_etherdev_mq(sizeof(struct rtw_netdev_priv_indicator), 4);
        if (!pnetdev)
                goto RETURN;

        pnetdev->dev.type = &wlan_type;
        pnpi = netdev_priv(pnetdev);
        pnpi->priv = old_priv;
        pnpi->sizeof_priv = sizeof_priv;

RETURN:
        return pnetdev;
}

struct net_device *rtw_alloc_etherdev(int sizeof_priv)
{
        struct net_device *pnetdev;
        struct rtw_netdev_priv_indicator *pnpi;

        pnetdev = alloc_etherdev_mq(sizeof(struct rtw_netdev_priv_indicator), 4);
        if (!pnetdev)
                goto RETURN;

        pnpi = netdev_priv(pnetdev);

        pnpi->priv = vzalloc(sizeof_priv);
        if (!pnpi->priv) {
                free_netdev(pnetdev);
                pnetdev = NULL;
                goto RETURN;
        }

        pnpi->sizeof_priv = sizeof_priv;
RETURN:
        return pnetdev;
}

void rtw_free_netdev(struct net_device *netdev)
{
        struct rtw_netdev_priv_indicator *pnpi;

        if (!netdev)
                goto RETURN;

        pnpi = netdev_priv(netdev);

        if (!pnpi->priv)
                goto RETURN;

        vfree(pnpi->priv);
        free_netdev(netdev);

RETURN:
        return;
}

int rtw_change_ifname(struct adapter *padapter, const char *ifname)
{
        struct net_device *pnetdev;
        struct net_device *cur_pnetdev;
        struct rereg_nd_name_data *rereg_priv;
        int ret;

        if (!padapter)
                goto error;

        cur_pnetdev = padapter->pnetdev;
        rereg_priv = &padapter->rereg_nd_name_priv;

        /* free the old_pnetdev */
        if (rereg_priv->old_pnetdev) {
                free_netdev(rereg_priv->old_pnetdev);
                rereg_priv->old_pnetdev = NULL;
        }

        if (!rtnl_is_locked())
                unregister_netdev(cur_pnetdev);
        else
                unregister_netdevice(cur_pnetdev);

        rtw_proc_remove_one(cur_pnetdev);

        rereg_priv->old_pnetdev = cur_pnetdev;

        pnetdev = rtw_init_netdev(padapter);
        if (!pnetdev)  {
                ret = -1;
                goto error;
        }

        SET_NETDEV_DEV(pnetdev, dvobj_to_dev(adapter_to_dvobj(padapter)));

        rtw_init_netdev_name(pnetdev, ifname);

        memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);

        if (!rtnl_is_locked())
                ret = register_netdev(pnetdev);
        else
                ret = register_netdevice(pnetdev);
        if (ret != 0)
                goto error;

        rtw_proc_init_one(pnetdev);
        return 0;
error:
        return -1;
}

void rtw_buf_update(u8 **buf, u32 *buf_len, u8 *src, u32 src_len)
{
        u32 dup_len = 0;
        u8 *ori = NULL;
        u8 *dup = NULL;

        if (!buf || !buf_len)
                return;

        if (!src || !src_len)
                goto keep_ori;

        /* duplicate src */
        dup = kmalloc(src_len, GFP_ATOMIC);
        if (dup) {
                dup_len = src_len;
                memcpy(dup, src, dup_len);
        }

keep_ori:
        ori = *buf;

        /* replace buf with dup */
        *buf_len = 0;
        *buf = dup;
        *buf_len = dup_len;

        /* free ori */
        kfree(ori);
}

/**
 * rtw_cbuf_full - test if cbuf is full
 * @cbuf: pointer of struct rtw_cbuf
 *
 * Returns: true if cbuf is full
 */
inline bool rtw_cbuf_full(struct rtw_cbuf *cbuf)
{
        return (cbuf->write == cbuf->read - 1) ? true : false;
}

/**
 * rtw_cbuf_empty - test if cbuf is empty
 * @cbuf: pointer of struct rtw_cbuf
 *
 * Returns: true if cbuf is empty
 */
inline bool rtw_cbuf_empty(struct rtw_cbuf *cbuf)
{
        return (cbuf->write == cbuf->read) ? true : false;
}

/**
 * rtw_cbuf_push - push a pointer into cbuf
 * @cbuf: pointer of struct rtw_cbuf
 * @buf: pointer to push in
 *
 * Lock free operation, be careful of the use scheme
 * Returns: true push success
 */
bool rtw_cbuf_push(struct rtw_cbuf *cbuf, void *buf)
{
        if (rtw_cbuf_full(cbuf))
                return _FAIL;

        if (0)
                DBG_88E("%s on %u\n", __func__, cbuf->write);
        cbuf->bufs[cbuf->write] = buf;
        cbuf->write = (cbuf->write + 1) % cbuf->size;

        return _SUCCESS;
}

/**
 * rtw_cbuf_pop - pop a pointer from cbuf
 * @cbuf: pointer of struct rtw_cbuf
 *
 * Lock free operation, be careful of the use scheme
 * Returns: pointer popped out
 */
void *rtw_cbuf_pop(struct rtw_cbuf *cbuf)
{
        void *buf;
        if (rtw_cbuf_empty(cbuf))
                return NULL;

        if (0)
                DBG_88E("%s on %u\n", __func__, cbuf->read);
        buf = cbuf->bufs[cbuf->read];
        cbuf->read = (cbuf->read + 1) % cbuf->size;

        return buf;
}

/**
 * rtw_cbuf_alloc - allocate a rtw_cbuf with given size and do initialization
 * @size: size of pointer
 *
 * Returns: pointer of srtuct rtw_cbuf, NULL for allocation failure
 */
struct rtw_cbuf *rtw_cbuf_alloc(u32 size)
{
        struct rtw_cbuf *cbuf;

        cbuf = kmalloc(sizeof(*cbuf) + sizeof(void *) * size, GFP_KERNEL);

        if (cbuf) {
                cbuf->write = 0;
                cbuf->read = 0;
                cbuf->size = size;
        }
        return cbuf;
}