IO设备管理

字数统计: 2.7k字   |   阅读时长≈ 11分

I/O设备管理

IO设备管理层框架从下往上一次共三层：设备驱动层 –> 设备驱动框架层 –> IO设备管理层

IO设备框架向下操作硬件，向上提供统一的一套接口给应用程序调用，使得应用程序不用关系具体的硬件操作，更换硬件执行修改设备驱动操作硬件相关的代码。

  • IO设备管理层

1.实现了对设备驱动程序的封装，使程序完全脱离了具体的硬件。

2.提供给应用程序的接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/************** device.c *******************/
// 1.通过名字查找设备，返回设备句柄
rt_device_t rt_device_find(const char *name);
// 2.通过设备句柄打开这个设备
rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag);
// 3.通过设备句柄，读设备数据
rt_size_t rt_device_read(rt_device_t dev,
                         rt_off_t    pos,
                         void       *buffer,
                         rt_size_t   size);

rt_size_t rt_device_write(rt_device_t dev,
                          rt_off_t    pos,
                          const void *buffer,
                          rt_size_t   size)
// 4.关闭设备
rt_err_t rt_device_close(rt_device_t dev);

3.提供给驱动程序实现的：

1
2
3
4
// 驱动程序实例化一个设备对象，并通过此接口注册到IO设备管理层
rt_err_t rt_device_register(rt_device_t dev,
                            const char *name,
                            rt_uint16_t flags);
  • 设备框架层

1.对同类硬件设备驱动做抽象：将不同厂家的同类硬件设备驱动中相同的部分抽取出来。

2.将不同的部分留出接口，由驱动程序实现。

3.负责创建和注册IO设备（就是设备框架层将不同部分留出的接口，设备驱动层需要去实现这些接口，注册给设备框架层使用）。

4.通过IO管理层提供的接口，注册一个串口设备到IO管理层：

5.设备驱动框架是对同类设备的抽象（这一层可以没有），例如：显示设备和ssd1306的关系，显示设备可以是ssd1306或者lcd显示屏，但它们都属于显示设备都能够显示一个字母、显示一个数字。

设备框架层就是对同类设备的抽象，同类设备的一些共性。

4.不同芯片厂家的串口操作方式是不一样的，但他们肯定都有putc、getc、config的这些功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/*************** serial.c ******************/
// 1.提供给驱动层使用的，注册一个设备到IO管理层
rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
                               const char              *name,
                               rt_uint32_t              flag,
                               void                    *data)
{
    rt_err_t ret;
    struct rt_device *device; // 待封装的设备对象

    device = &(serial->parent);

    device->type        = RT_Device_Class_Char;
    device->rx_indicate = RT_NULL;
    device->tx_complete = RT_NULL;

    device->ops         = &serial_ops;  

    /* register a character device */
    ret = rt_device_register(device, name, flag); // 注册封装好的设备对象到IO管理层

....
    return ret;
}

struct serial_ops // 设备对象方法
{
    .config = stm32_configure,
    .putc = stm32_putc,
    .getc = stm32_getc
}

对于逻辑操作简单的设备，可以跳过设备框架层，直接注册到IO设备管理层，将设备框架层必要的东西直接在设备驱动层实现。

  • 设备驱动层

通常是直接调用厂家提供的操作硬件寄存器函数

1.是一组直接驱使硬件工作的程序，实现访问硬件提供的功能。

2.设备框架层提供的接口，注册一个串口设备到设备框架层。

硬件相关的：配置具体的外设、读、写等，硬件的功能实现函数。

这些硬件相关的操作函数都将被，驱动层使用注意不是调用（在驱动层封装成硬件设备对象的方法，再由驱动层注册到IO设备层），所以IO设备驱动层对设备对象的操作相当于直接调用了这些函数。

以上的这些层都是为应用程序服务的，宏观上这些层都可以叫做驱动，驱动只提供方法不会操作硬件，只有应用程序里面才会调用这些设备对象的方法操作硬件，可能进行设备初始化、打开、关闭、读、写，根据设备提供的方法不一样不一定所有的设备都有这些方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/******************** drv_uart.c **************************/
// 初始化串口设备
static rt_err_t stm32_configure(struct rt_serial_device *serial, struct serial_configure *cfg) 
{
.....
    if (HAL_UART_Init(&uart->handle) != HAL_OK)
    {
        return -RT_ERROR;
    }

    return RT_EOK;
}

// 向串口设备写一个字符
static int stm32_putc(struct rt_serial_device *serial, char c) 
{
...
    uart->handle.Instance->DR = c;
    while (__HAL_UART_GET_FLAG(&(uart->handle), UART_FLAG_TC) == RESET);
    return 1;
}

// 从串口设备读一个字符
static int stm32_getc(struct rt_serial_device *serial) 
{
...
    ch = uart->handle.Instance->DR & 0xff;
    return ch;
}

// 注册一个设备到设备框架层，在系统启动时调用，会注册设备到IO管理层，也可以封装成设备对象方法，在应用程序需要的时候调用初始化设备
int rt_hw_usart_init(void)
{
    rt_size_t obj_num = sizeof(uart_obj) / sizeof(struct stm32_uart);
    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
    rt_err_t result = 0;

    stm32_uart_get_dma_config();

    for (int i = 0; i < obj_num; i++)
    {
        /* init UART object */
        uart_obj[i].config = &uart_config[i];
        uart_obj[i].serial.ops    = &stm32_uart_ops;
        uart_obj[i].serial.config = config;

        /* register UART device */
        result = rt_hw_serial_register(&uart_obj[i].serial, uart_obj[i].config->name,
                                       RT_DEVICE_FLAG_RDWR
                                       | RT_DEVICE_FLAG_INT_RX
                                       | RT_DEVICE_FLAG_INT_TX
                                       | uart_obj[i].uart_dma_flag
                                       , NULL);
        RT_ASSERT(result == RT_EOK);
    }

    return result;
}

  • 应用程序

例如shell.c是一个应用程序，它和用户直接交互

应用程序：实现产品具体功能的代码，与用户交互的、显示用的、一个触摸的键盘，分别获取用户的输入做出反应、输出信息给用户看、得到用户的输入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/******************** shell.c ****************************/
// 通过名字设置一个设备给finsh用
void finsh_set_device(const char *device_name)
{
   ...
    /* open this device and set the new device in finsh shell */
    if (rt_device_open(dev, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX | \  // 打开一个设备里面会调用设备提供的open函数
                       RT_DEVICE_FLAG_STREAM) == RT_EOK)
    {
        if (shell->device != RT_NULL)
        {
            /* close old finsh device */
            rt_device_close(shell->device);  // 关闭设备里面会调用设备提供的close函数
            rt_device_set_rx_indicate(shell->device, RT_NULL);
        }
    }

     ...
}

从上面的代码可以看出，只有应用程序才会去操作硬件，驱动程序只提供操作硬件的方法。

小结：

分层思想的原则：

1.确定本层的职责，搞清承上启下的对象是谁。

2.实现本层职责时，提供好给上层调用的接口和对象。

3.如果超出本层职责（操作过于细节），那么提供注册函数给自己的下层调用，让下层提供一个实现具体细节的方法给自己使用。

4.一般方法和信息都是通过对象的形式在层与层之间传递。

  • I/O设备对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// 设备类型
enum rt_device_class_type
{
    RT_Device_Class_Char = 0,                           /**< 字符设备 */
    RT_Device_Class_Block,                              /**< 块设备 */
    RT_Device_Class_NetIf,                              /**< 网络接口设备 */
    RT_Device_Class_MTD,                                /**< 内存设备 */
    RT_Device_Class_CAN,                                /**< can设备 */
    RT_Device_Class_RTC,                                /**< RTC设备 */
    RT_Device_Class_Sound,                              /**< 声音设备 */
    RT_Device_Class_Graphic,                            /**< 图形设备 */
    RT_Device_Class_I2CBUS,                             /**< I2C总线设备 */
    RT_Device_Class_USBDevice,                          /**< USB从设备 */
    RT_Device_Class_USBHost,                            /**< USB主设备 */
    RT_Device_Class_SPIBUS,                             /**< SPI总线 */
    RT_Device_Class_SPIDevice,                          /**< SPI设备 */
    RT_Device_Class_SDIO,                               /**< SDIO总线设备 */
    RT_Device_Class_PM,                                 /**< PM伪设备 */
    RT_Device_Class_Pipe,                               /**< 管道设备 */
    RT_Device_Class_Portal,                             /**< 门户设备 */
    RT_Device_Class_Timer,                              /**< 计时器设备 */
    RT_Device_Class_Miscellaneous,                      /**< 其他设备 */
    RT_Device_Class_Sensor,                             /**< 传感器设备 */
    RT_Device_Class_Touch,                              /**< 触摸设备 */
    RT_Device_Class_PHY,                                /**< 物理设备 */
    RT_Device_Class_Unknown                             /**< 未知设备 */
};

/**
 * 设备对象
 */
struct rt_device
{
    struct rt_object          parent;                   /**< 内核对象基类 */

    enum rt_device_class_type type;                     /**< 设备类型 */
    rt_uint16_t               flag;                     /**< 设备参数 */
    rt_uint16_t               open_flag;                /**< 设备打开标志 */

    rt_uint8_t                ref_count;                /**< 设备被引用次数 */
    rt_uint8_t                device_id;                /**< 设备id：0 - 255 */

    /* 数据收发回调 */
    rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
    rt_err_t (*tx_complete)(rt_device_t dev, void *buffer);
    
    const struct rt_device_ops *ops;


    void                     *user_data;                /**< 设备私有数据 */
};
typedef struct rt_device *rt_device_t;

常见设备：字符设备：允许非结构数据传输，串行传输一次一个字节，块设备：每次传输一个数据块，如512byte，数据块是硬件强制性的，通常情况下操作，先读一个块数据，改变之中的一部分数据然后再写回去。

  • 访问IO设备

设备的多种打开方式：

1
2
3
4
5
6
7
8
9
10
11
#define RT_DEVICE_FLAG_INT_RX           0x100           /**< INT mode on Rx */
#define RT_DEVICE_FLAG_DMA_RX           0x200           /**< DMA mode on Rx */
#define RT_DEVICE_FLAG_INT_TX           0x400           /**< INT mode on Tx */
#define RT_DEVICE_FLAG_DMA_TX           0x800           /**< DMA mode on Tx */

#define RT_DEVICE_OFLAG_CLOSE           0x000           /**< device is closed */
#define RT_DEVICE_OFLAG_RDONLY          0x001           /**< read only access */
#define RT_DEVICE_OFLAG_WRONLY          0x002           /**< write only access */
#define RT_DEVICE_OFLAG_RDWR            0x003           /**< read and write */
#define RT_DEVICE_OFLAG_OPEN            0x008           /**< device is opened */
#define RT_DEVICE_OFLAG_MASK            0xf0f           /**< mask of open flag */

如果上层应用程序需要设置设备的接收回调函数，则必须以 RT_DEVICE_FLAG_INT_TX 或者 RT_DEVICE_FLAG_DMA_RX 的方式打开设备，否则不会回调函数。

  • 打开IO设备
1
2
// 该函数主要执行 dev->open();
rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag);

rt_device_open() 和 rt_device_close() 需成对使用。

  • 控制设备
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 该函数主要执行 dev->control();
rt_err_t rt_device_control(rt_device_t dev, int cmd, void *arg);

/**
 * general device commands
 */
#define RT_DEVICE_CTRL_RESUME           0x01            /**< resume device */
#define RT_DEVICE_CTRL_SUSPEND          0x02            /**< suspend device */
#define RT_DEVICE_CTRL_CONFIG           0x03            /**< configure device */
#define RT_DEVICE_CTRL_CLOSE            0x04            /**< close device */

#define RT_DEVICE_CTRL_SET_INT          0x10            /**< set interrupt */
#define RT_DEVICE_CTRL_CLR_INT          0x11            /**< clear interrupt */
#define RT_DEVICE_CTRL_GET_INT          0x12            /**< get interrupt status */
  • 设备读写
1
2
3
4
5
6
7
8
9
10
// pos:根据设备的不同有不同的意义，读串口设备底层会忽略这个参数，pos参数没有一样
rt_size_t rt_device_read(rt_device_t dev,
                         rt_off_t    pos,
                         void       *buffer,
                         rt_size_t   size);
// pos：写入数据在 buffer 的偏移量
rt_size_t rt_device_write(rt_device_t dev,
                          rt_off_t    pos,
                          const void *buffer,
                          rt_size_t   size);
  • 数据收发回调

接收回调：

1
2
3
4
5
6
7
8
9
// 设置接收数据回调：设置一个回调函数，当硬件设备接收到数据时，
// 会回调这个函数，并把数据长度放在size中，上层应用线程收到指示后，立刻从设备中读取数据
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))
{
    dev->rx_indicate = rx_ind; // 在上层定义，注册到对象里面，底层驱动在条件满足的时候会调用该函数

    return RT_EOK;
}

发送回调：

1
2
3
4
5
6
7
8
9
// 设置发送完数据回调：当硬件设备发送完数据，驱动程序回调这个函数并把发送完成的数据块地址buffer作为参数传递给上层应用，
// 上层应用线程收到指示后会根据buffer的情况，释放buffer内存或将其作为下一个写数据的缓存。
rt_err_t rt_device_set_tx_complete(rt_device_t dev,
                          rt_err_t (*tx_done)(rt_device_t dev, void *buffer))
{
    dev->tx_complete = tx_done; // 在上层定义，注册到对象里面，底层驱动在条件满足的时候会调用该函数

    return RT_EOK;
}

上面两个函数都是应用程序注册给底层硬件驱动回调用的，相当于是底层驱动异步通知应用程序执行的操作结果。是一种层与层之间的沟通方式，和底层注册到上层类似。

本章小结：

1.没有提供驱动的设备，或者自己另外需要添加的设备，需要根据驱动框架自己实现设备的方法。
2.动态创建的设备销毁时要记得释放设备控制块占用的内存。
3.IO设备在应用程序的写使用示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int xxx_writedata(uint8_t* buffer, size_t buff_size)
{
    ....
    device = rt_device_find("spi1");
    if (!device)
    {
        rt_kprintf("find spi1 failed!\n");
        return RT_ERROR;
    }
    err = rt_device_open(device, RT_DEVICE_OFLAG_WRONLY);
    if (err < 0)
    {
        rt_kprintf("open spi1 failed!\n");
        return RT_ERROR;
    }

    rt_device_write(device, 0, (const void *)buffer, buff_size);
    rt_device_close(device);
    ....
}
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

从事嵌入式开发