/* * Copyright (c) 2006-2021, 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 * 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. * 2021-03-19 Meco Man remove rt_device_init_all() * 2024-09-15 milo fix log format issue * fix reopen with a different oflag issue */ #include #define DBG_TAG "kernel.device" #ifdef RT_DEBUG_DEVICE #define DBG_LVL DBG_LOG #else #define DBG_LVL DBG_WARNING #endif /* defined (RT_DEBUG_DEVICE) */ #include #ifdef RT_USING_POSIX_DEVIO #include /* for wqueue_init */ #endif /* RT_USING_POSIX_DEVIO */ #ifdef RT_USING_DFS_V2 #include #endif /* RT_USING_DFS_V2 */ #ifdef RT_USING_DEVICE #ifdef RT_USING_DEVICE_OPS #define device_init (dev->ops ? dev->ops->init : RT_NULL) #define device_open (dev->ops ? dev->ops->open : RT_NULL) #define device_close (dev->ops ? dev->ops->close : RT_NULL) #define device_read (dev->ops ? dev->ops->read : RT_NULL) #define device_write (dev->ops ? dev->ops->write : RT_NULL) #define device_control (dev->ops ? dev->ops->control : RT_NULL) #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 /* RT_USING_DEVICE_OPS */ /** * @brief This function registers a device driver with a specified name. * * @param dev is the pointer of device driver structure. * * @param name is the device driver's name. * * @param flags is 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; #ifdef RT_USING_POSIX_DEVIO dev->fops = RT_NULL; rt_wqueue_init(&(dev->wait_queue)); #endif /* RT_USING_POSIX_DEVIO */ #ifdef RT_USING_DFS_V2 dfs_devfs_device_add(dev); #endif /* RT_USING_DFS_V2 */ return RT_EOK; } RTM_EXPORT(rt_device_register); /** * @brief This function removes a previously registered device driver. * * @param dev is the pointer of device driver structure. * * @return the error code, RT_EOK on successfully. */ rt_err_t rt_device_unregister(rt_device_t dev) { /* parameter check */ 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); /** * @brief This function finds a device driver by specified name. * * @param name is 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) { return (rt_device_t)rt_object_find(name, RT_Object_Class_Device); } RTM_EXPORT(rt_device_find); #ifdef RT_USING_HEAP /** * @brief This function creates a device object with user data size. * * @param type is the type of the device object. * * @param attach_size is 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 total 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); /** * @brief This function destroy the specific device object. * * @param dev is a specific device object. */ void rt_device_destroy(rt_device_t dev) { /* parameter check */ RT_ASSERT(dev != RT_NULL); RT_ASSERT(rt_object_get_type(&dev->parent) == RT_Object_Class_Null); 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 /* RT_USING_HEAP */ /** * @brief This function will initialize the specified device. * * @param dev is the pointer of device driver structure. * * @return the result, RT_EOK on successfully. */ 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) { LOG_E("To initialize device:%.*s failed. The error code is %d", RT_NAME_MAX, dev->parent.name, result); } else { dev->flag |= RT_DEVICE_FLAG_ACTIVATED; } } } return result; } /** * @brief This function will open a device. * * @param dev is the pointer of device driver structure. * * @param oflag is the flags for device open. * * @return the result, RT_EOK on successfully. */ rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag) { rt_err_t result = RT_EOK; /* parameter check */ 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) { LOG_E("To initialize device:%.*s failed. The error code is %d", RT_NAME_MAX, 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; } /* device is not opened or opened by other oflag, call device_open interface */ if (!(dev->open_flag & RT_DEVICE_OFLAG_OPEN) || ((dev->open_flag & RT_DEVICE_OFLAG_MASK) != ((oflag & RT_DEVICE_OFLAG_MASK) | RT_DEVICE_OFLAG_OPEN))) { 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); /** * @brief This function will close a device. * * @param dev is the pointer of device driver structure. * * @return the result, RT_EOK on successfully. */ rt_err_t rt_device_close(rt_device_t dev) { rt_err_t result = RT_EOK; /* parameter check */ 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); /** * @brief This function will read some data from a device. * * @param dev is the pointer of device driver structure. * * @param pos is the position when reading. * * @param buffer is a data buffer to save the read data. * * @param size is the size of buffer. * * @return the actually read size on successful, otherwise 0 will be returned. * * @note the unit of size/pos is a block for block device. */ rt_ssize_t rt_device_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size) { /* parameter check */ 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); /** * @brief This function will write some data to a device. * * @param dev is the pointer of device driver structure. * * @param pos is the position when writing. * * @param buffer is the data buffer to be written to device. * * @param size is the size of buffer. * * @return the actually written size on successful, otherwise 0 will be returned. * * @note the unit of size/pos is a block for block device. */ rt_ssize_t rt_device_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size) { /* parameter check */ 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); /** * @brief This function will perform a variety of control functions on devices. * * @param dev is the pointer of device driver structure. * * @param cmd is the command sent to device. * * @param arg is the argument of command. * * @return the result, -RT_ENOSYS for failed. */ rt_err_t rt_device_control(rt_device_t dev, int cmd, void *arg) { /* parameter check */ 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); /** * @brief This function will set the reception indication callback function. This callback function * is invoked when this device receives data. * * @param dev is the pointer of device driver structure. * * @param rx_ind is 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)) { /* parameter check */ 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); /** * @brief This function will set a callback function. The callback function * will be called when device has written data to physical hardware. * * @param dev is the pointer of device driver structure. * * @param tx_done is 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)) { /* parameter check */ 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 /* RT_USING_DEVICE */