/*
 * Copyright (c) 2006-2018, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date Author Notes
 * 2007年01月21日 Bernard the first version
 * 2010年05月04日 Bernard add rt_device_init implementation
 * 2012年10月20日 Bernard add device check in register function,
 * provided by Rob <rdent@iinet.net.au>
 * 2012年12月25日 Bernard return RT_EOK if the device interface not exist.
 * 2013年07月09日 Grissiom add ref_count support
 * 2016年04月02日 Bernard fix the open_flag initialization issue.
 */

#include <rtthread.h>
#if defined(RT_USING_POSIX)
#include <rtdevice.h> /* for wqueue_init */
#endif

#ifdef RT_USING_DEVICE

#ifdef RT_USING_DEVICE_OPS
#define device_init (dev->ops->init)
#define device_open (dev->ops->open)
#define device_close (dev->ops->close)
#define device_read (dev->ops->read)
#define device_write (dev->ops->write)
#define device_control (dev->ops->control)
#else
#define device_init (dev->init)
#define device_open (dev->open)
#define device_close (dev->close)
#define device_read (dev->read)
#define device_write (dev->write)
#define device_control (dev->control)
#endif

/**
 * This function registers a device driver with specified name.
 *
 * @param dev the pointer of device driver structure
 * @param name the device driver's name
 * @param flags the capabilities flag of device
 *
 * @return the error code, RT_EOK on initialization successfully.
 */
rt_err_t rt_device_register(rt_device_t dev,
 const char *name,
 rt_uint16_t flags)
{
 if (dev == RT_NULL)
 return -RT_ERROR;

 if (rt_device_find(name) != RT_NULL)
 return -RT_ERROR;

 rt_object_init(&(dev->parent), RT_Object_Class_Device, name);
 dev->flag = flags;
 dev->ref_count = 0;
 dev->open_flag = 0;

#if defined(RT_USING_POSIX)
 dev->fops = RT_NULL;
 rt_wqueue_init(&(dev->wait_queue));
#endif

 return RT_EOK;
}
RTM_EXPORT(rt_device_register);

/**
 * This function removes a previously registered device driver
 *
 * @param dev the pointer of device driver structure
 *
 * @return the error code, RT_EOK on successfully.
 */
rt_err_t rt_device_unregister(rt_device_t dev)
{
 RT_ASSERT(dev != RT_NULL);
 RT_ASSERT(rt_object_get_type(&dev->parent) == RT_Object_Class_Device);
 RT_ASSERT(rt_object_is_systemobject(&dev->parent));

 rt_object_detach(&(dev->parent));

 return RT_EOK;
}
RTM_EXPORT(rt_device_unregister);

/**
 * This function initializes all registered device driver
 *
 * @return the error code, RT_EOK on successfully.
 *
 * @deprecated since 1.2.x, this function is not needed because the initialization
 * of a device is performed when applicaiton opens it.
 */
rt_err_t rt_device_init_all(void)
{
 return RT_EOK;
}

/**
 * This function finds a device driver by specified name.
 *
 * @param name the device driver's name
 *
 * @return the registered device driver on successful, or RT_NULL on failure.
 */
rt_device_t rt_device_find(const char *name)
{
 struct rt_object *object;
 struct rt_list_node *node;
 struct rt_object_information *information;

 /* enter critical */
 if (rt_thread_self() != RT_NULL)
 rt_enter_critical();

 /* try to find device object */
 information = rt_object_get_information(RT_Object_Class_Device);
 RT_ASSERT(information != RT_NULL);
 for (node = information->object_list.next;
 node != &(information->object_list);
 node = node->next)
 {
 object = rt_list_entry(node, struct rt_object, list);
 if (rt_strncmp(object->name, name, RT_NAME_MAX) == 0)
 {
 /* leave critical */
 if (rt_thread_self() != RT_NULL)
 rt_exit_critical();

 return (rt_device_t)object;
 }
 }

 /* leave critical */
 if (rt_thread_self() != RT_NULL)
 rt_exit_critical();

 /* not found */
 return RT_NULL;
}
RTM_EXPORT(rt_device_find);

#ifdef RT_USING_HEAP
/**
 * This function creates a device object with user data size.
 *
 * @param type, the kind type of this device object.
 * @param attach_size, the size of user data.
 *
 * @return the allocated device object, or RT_NULL when failed.
 */
rt_device_t rt_device_create(int type, int attach_size)
{
 int size;
 rt_device_t device;

 size = RT_ALIGN(sizeof(struct rt_device), RT_ALIGN_SIZE);
 attach_size = RT_ALIGN(attach_size, RT_ALIGN_SIZE);
 /* use the totoal size */
 size += attach_size;

 device = (rt_device_t)rt_malloc(size);
 if (device)
 {
 rt_memset(device, 0x0, sizeof(struct rt_device));
 device->type = (enum rt_device_class_type)type;
 }

 return device;
}
RTM_EXPORT(rt_device_create);

/**
 * This function destroy the specific device object.
 *
 * @param dev, the specific device object.
 */
void rt_device_destroy(rt_device_t dev)
{
 RT_ASSERT(dev != RT_NULL);
 RT_ASSERT(rt_object_get_type(&dev->parent) == RT_Object_Class_Device);
 RT_ASSERT(rt_object_is_systemobject(&dev->parent) == RT_FALSE);

 rt_object_detach(&(dev->parent));

 /* release this device object */
 rt_free(dev);
}
RTM_EXPORT(rt_device_destroy);
#endif

/**
 * This function will initialize the specified device
 *
 * @param dev the pointer of device driver structure
 *
 * @return the result
 */
rt_err_t rt_device_init(rt_device_t dev)
{
 rt_err_t result = RT_EOK;

 RT_ASSERT(dev != RT_NULL);

 /* get device init handler */
 if (device_init != RT_NULL)
 {
 if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
 {
 result = device_init(dev);
 if (result != RT_EOK)
 {
 rt_kprintf("To initialize device:%s failed. The error code is %d\n",
 dev->parent.name, result);
 }
 else
 {
 dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
 }
 }
 }

 return result;
}

/**
 * This function will open a device
 *
 * @param dev the pointer of device driver structure
 * @param oflag the flags for device open
 *
 * @return the result
 */
rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag)
{
 rt_err_t result = RT_EOK;

 RT_ASSERT(dev != RT_NULL);
 RT_ASSERT(rt_object_get_type(&dev->parent) == RT_Object_Class_Device);

 /* if device is not initialized, initialize it. */
 if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
 {
 if (device_init != RT_NULL)
 {
 result = device_init(dev);
 if (result != RT_EOK)
 {
 rt_kprintf("To initialize device:%s failed. The error code is %d\n",
 dev->parent.name, result);

 return result;
 }
 }

 dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
 }

 /* device is a stand alone device and opened */
 if ((dev->flag & RT_DEVICE_FLAG_STANDALONE) &&
 (dev->open_flag & RT_DEVICE_OFLAG_OPEN))
 {
 return -RT_EBUSY;
 }

 /* call device open interface */
 if (device_open != RT_NULL)
 {
 result = device_open(dev, oflag);
 }
 else
 {
 /* set open flag */
 dev->open_flag = (oflag & RT_DEVICE_OFLAG_MASK);
 }

 /* set open flag */
 if (result == RT_EOK || result == -RT_ENOSYS)
 {
 dev->open_flag |= RT_DEVICE_OFLAG_OPEN;

 dev->ref_count++;
 /* don't let bad things happen silently. If you are bitten by this assert,
 * please set the ref_count to a bigger type. */
 RT_ASSERT(dev->ref_count != 0);
 }

 return result;
}
RTM_EXPORT(rt_device_open);

/**
 * This function will close a device
 *
 * @param dev the pointer of device driver structure
 *
 * @return the result
 */
rt_err_t rt_device_close(rt_device_t dev)
{
 rt_err_t result = RT_EOK;

 RT_ASSERT(dev != RT_NULL);
 RT_ASSERT(rt_object_get_type(&dev->parent) == RT_Object_Class_Device);

 if (dev->ref_count == 0)
 return -RT_ERROR;

 dev->ref_count--;

 if (dev->ref_count != 0)
 return RT_EOK;

 /* call device close interface */
 if (device_close != RT_NULL)
 {
 result = device_close(dev);
 }

 /* set open flag */
 if (result == RT_EOK || result == -RT_ENOSYS)
 dev->open_flag = RT_DEVICE_OFLAG_CLOSE;

 return result;
}
RTM_EXPORT(rt_device_close);

/**
 * This function will read some data from a device.
 *
 * @param dev the pointer of device driver structure
 * @param pos the position of reading
 * @param buffer the data buffer to save read data
 * @param size the size of buffer
 *
 * @return the actually read size on successful, otherwise negative returned.
 *
 * @note since 0.4.0, the unit of size/pos is a block for block device.
 */
rt_size_t rt_device_read(rt_device_t dev,
 rt_off_t pos,
 void *buffer,
 rt_size_t size)
{
 RT_ASSERT(dev != RT_NULL);
 RT_ASSERT(rt_object_get_type(&dev->parent) == RT_Object_Class_Device);

 if (dev->ref_count == 0)
 {
 rt_set_errno(-RT_ERROR);
 return 0;
 }

 /* call device read interface */
 if (device_read != RT_NULL)
 {
 return device_read(dev, pos, buffer, size);
 }

 /* set error code */
 rt_set_errno(-RT_ENOSYS);

 return 0;
}
RTM_EXPORT(rt_device_read);

/**
 * This function will write some data to a device.
 *
 * @param dev the pointer of device driver structure
 * @param pos the position of written
 * @param buffer the data buffer to be written to device
 * @param size the size of buffer
 *
 * @return the actually written size on successful, otherwise negative returned.
 *
 * @note since 0.4.0, the unit of size/pos is a block for block device.
 */
rt_size_t rt_device_write(rt_device_t dev,
 rt_off_t pos,
 const void *buffer,
 rt_size_t size)
{
 RT_ASSERT(dev != RT_NULL);
 RT_ASSERT(rt_object_get_type(&dev->parent) == RT_Object_Class_Device);

 if (dev->ref_count == 0)
 {
 rt_set_errno(-RT_ERROR);
 return 0;
 }

 /* call device write interface */
 if (device_write != RT_NULL)
 {
 return device_write(dev, pos, buffer, size);
 }

 /* set error code */
 rt_set_errno(-RT_ENOSYS);

 return 0;
}
RTM_EXPORT(rt_device_write);

/**
 * This function will perform a variety of control functions on devices.
 *
 * @param dev the pointer of device driver structure
 * @param cmd the command sent to device
 * @param arg the argument of command
 *
 * @return the result
 */
rt_err_t rt_device_control(rt_device_t dev, int cmd, void *arg)
{
 RT_ASSERT(dev != RT_NULL);
 RT_ASSERT(rt_object_get_type(&dev->parent) == RT_Object_Class_Device);

 /* call device write interface */
 if (device_control != RT_NULL)
 {
 return device_control(dev, cmd, arg);
 }

 return -RT_ENOSYS;
}
RTM_EXPORT(rt_device_control);

/**
 * This function will set the reception indication callback function. This callback function
 * is invoked when this device receives data.
 *
 * @param dev the pointer of device driver structure
 * @param rx_ind the indication callback function
 *
 * @return RT_EOK
 */
rt_err_t
rt_device_set_rx_indicate(rt_device_t dev,
 rt_err_t (*rx_ind)(rt_device_t dev, rt_size_t size))
{
 RT_ASSERT(dev != RT_NULL);
 RT_ASSERT(rt_object_get_type(&dev->parent) == RT_Object_Class_Device);

 dev->rx_indicate = rx_ind;

 return RT_EOK;
}
RTM_EXPORT(rt_device_set_rx_indicate);

/**
 * This function will set the indication callback function when device has
 * written data to physical hardware.
 *
 * @param dev the pointer of device driver structure
 * @param tx_done the indication callback function
 *
 * @return RT_EOK
 */
rt_err_t
rt_device_set_tx_complete(rt_device_t dev,
 rt_err_t (*tx_done)(rt_device_t dev, void *buffer))
{
 RT_ASSERT(dev != RT_NULL);
 RT_ASSERT(rt_object_get_type(&dev->parent) == RT_Object_Class_Device);

 dev->tx_complete = tx_done;

 return RT_EOK;
}
RTM_EXPORT(rt_device_set_tx_complete);

#endif