409 lines
10 KiB
C
409 lines
10 KiB
C
/*
|
|
* File : device.c
|
|
* This file is part of RT-Thread RTOS
|
|
* COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* 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>
|
|
|
|
#ifdef RT_USING_DEVICE
|
|
|
|
/**
|
|
* 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 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;
|
|
|
|
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_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;
|
|
|
|
extern struct rt_object_information rt_object_container[];
|
|
|
|
/* enter critical */
|
|
if (rt_thread_self() != RT_NULL)
|
|
rt_enter_critical();
|
|
|
|
/* try to find device object */
|
|
information = &rt_object_container[RT_Object_Class_Device];
|
|
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);
|
|
|
|
/**
|
|
* 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 (dev->init != RT_NULL)
|
|
{
|
|
if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
|
|
{
|
|
result = dev->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);
|
|
|
|
/* if device is not initialized, initialize it. */
|
|
if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
|
|
{
|
|
if (dev->init != RT_NULL)
|
|
{
|
|
result = dev->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 (dev->open != RT_NULL)
|
|
{
|
|
result = dev->open(dev, oflag);
|
|
}
|
|
|
|
/* set open flag */
|
|
if (result == RT_EOK || result == -RT_ENOSYS)
|
|
{
|
|
dev->open_flag = oflag | 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);
|
|
|
|
if (dev->ref_count == 0)
|
|
return -RT_ERROR;
|
|
|
|
dev->ref_count--;
|
|
|
|
if (dev->ref_count != 0)
|
|
return RT_EOK;
|
|
|
|
/* call device close interface */
|
|
if (dev->close != RT_NULL)
|
|
{
|
|
result = dev->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);
|
|
|
|
if (dev->ref_count == 0)
|
|
{
|
|
rt_set_errno(-RT_ERROR);
|
|
return 0;
|
|
}
|
|
|
|
/* call device read interface */
|
|
if (dev->read != RT_NULL)
|
|
{
|
|
return dev->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);
|
|
|
|
if (dev->ref_count == 0)
|
|
{
|
|
rt_set_errno(-RT_ERROR);
|
|
return 0;
|
|
}
|
|
|
|
/* call device write interface */
|
|
if (dev->write != RT_NULL)
|
|
{
|
|
return dev->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, rt_uint8_t cmd, void *arg)
|
|
{
|
|
RT_ASSERT(dev != RT_NULL);
|
|
|
|
/* call device write interface */
|
|
if (dev->control != RT_NULL)
|
|
{
|
|
return dev->control(dev, cmd, arg);
|
|
}
|
|
|
|
return RT_EOK;
|
|
}
|
|
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);
|
|
|
|
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);
|
|
|
|
dev->tx_complete = tx_done;
|
|
|
|
return RT_EOK;
|
|
}
|
|
RTM_EXPORT(rt_device_set_tx_complete);
|
|
|
|
#endif
|