2. 程式人生 > >Zephyr Kernel 裝置驅動和裝置模型(二)

Zephyr Kernel 裝置驅動和裝置模型(二)

阿新 • • 發佈：2019-01-08

   C++語言有封裝、繼承、多型的特點。C語言也可以面向物件和應用設計模式，關鍵就在於如何實現面嚮物件語言的三個重要屬性，下面以watdog為例分析Zephyr裝置驅動和裝置模型。

struct device;

/**
 * @brief Static device information (In ROM) Per driver instance
 * @param name name of the device
 * @param init init function for the driver
 * @param config_info address of driver instance config information
 */

struct device_config {
    char    *name;
    int (*init)(struct device *device);
    void *config_info;
};

/**
 * @brief Runtime device structure (In memory) Per driver instance
 * @param device_config Build time config information
 * @param driver_api pointer to structure containing the API functions for
 * the device type. This pointer is filled in by the driver at init time.
 * @param driver_data river instance data. For driver use only
 */
struct device {
    struct device_config *config;
    void *driver_api;
    void *driver_data;
};

#define DEVICE_INIT(dev_name, drv_name, init_fn, data, cfg_info, level, prio) \
    \
    static struct device_config __config_##dev_name __used \
    __attribute__((__section__(".devconfig.init"))) = { \
        .name = drv_name, .init = (init_fn), \
        .config_info = (cfg_info) \
    }; \
    \
    static struct device (__device_##dev_name) __used \
    __attribute__((__section__(".init_" #level STRINGIFY(prio)))) = { \
         .config = &(__config_##dev_name), \
         .driver_data = data \
    }

（1）封裝性

  1. struct _Device_data;  
  2. typedefvoid (*process)(struct  _Device_data* pData);  
  3. typedefstruct  _Device_data  
  4. {  
  5.     int value;  
  6.     process pProcess;  
  7. }Data;  
    封裝性的意義在於，函式和資料是綁在一起的，資料和資料是綁在一起的。這樣，我們就可以通過簡單的一個結構指標訪問到所有的資料，遍歷所有的函式。封裝性，這是類擁有的屬性，當然也是資料結構體擁有的屬性。

（2）繼承性

  1. typedefstruct _parent  
  2. {  
  3.     int data_parent;  
  4. }Parent;  
  5. typedefstruct _Child  
  6. {  
  7.     struct _parent parent;  
  8.     int data_child;  
  9. }Child;  
    在設計C語言繼承性的時候，我們需要做的就是把基礎資料放在繼承的結構的首位置即可。這樣，不管是資料的訪問、資料的強轉、資料的訪問都不會有什麼問題。

（3）多型

  1. typedefstruct _Play  
  2. {  
  3.     void* pData;  
  4.     void (*start_play)(struct _Play* pPlay);  
  5. }Play;  
    多型，就是說用同一的介面程式碼處理不同的資料。比如說，這裡的Play結構就是一個通用的資料結構，我們也不清楚pData是什麼資料，start_play是什麼處理函式？但是，我們處理的時候只要呼叫pPlay->start_play(pPlay)就可以了。剩下來的事情我們不需要管，因為不同的介面會有不同的函式去處理，我們只要學會呼叫就可以了。

#include <nanokernel.h>

#include <init.h>
#include <clock_control.h>
#include "wdt_dw.h"

#ifdef WDT_DW_INT_MASK
static inline void _wdt_dw_int_unmask(void)
{
    sys_write32(sys_read32(WDT_DW_INT_MASK) & INT_UNMASK_IA,
                        WDT_DW_INT_MASK);
}
#else
#define _wdt_dw_int_unmask()
#endif

#ifdef CONFIG_WDT_DW_CLOCK_GATE
static inline void _wdt_dw_clock_config(struct device *dev)
{
    char *drv = CONFIG_WDT_DW_CLOCK_GATE_DRV_NAME;
    struct device *clk;

    clk = device_get_binding(drv);
    if (clk) {
        struct wdt_dw_runtime *context = dev->driver_data;

        context->clock = clk;
    }
}

static inline void _wdt_dw_clock_on(struct device *dev)
{
    struct wdt_dw_dev_config *config = dev->config->config_info;
    struct wdt_dw_runtime *context = dev->driver_data;

    clock_control_on(context->clock, config->clock_data);
}

static inline void _wdt_dw_clock_off(struct device *dev)
{
    struct wdt_dw_dev_config *config = dev->config->config_info;
    struct wdt_dw_runtime *context = dev->driver_data;

    clock_control_off(context->clock, config->clock_data);
}
#else
#define _wdt_dw_clock_config(...)
#define _wdt_dw_clock_on(...)
#define _wdt_dw_clock_off(...)
#endif

/**
 * Enables the clock for the peripheral watchdog
 */
static void wdt_dw_enable(struct device *dev)
{
    _wdt_dw_clock_on(dev);

#if defined(CONFIG_SOC_QUARK_SE) || defined(CONFIG_SOC_QUARK_D2000)
    sys_set_bit(SCSS_PERIPHERAL_BASE + SCSS_PERIPH_CFG0, 1);
#endif
}

static void wdt_dw_disable(struct device *dev)
{
    _wdt_dw_clock_off(dev);

#if defined(CONFIG_SOC_QUARK_SE) || defined(CONFIG_SOC_QUARK_D2000)
    sys_clear_bit(SCSS_PERIPHERAL_BASE + SCSS_PERIPH_CFG0, 1);
#endif
}

void wdt_dw_isr(void *arg)
{
    struct device *dev = arg;
    struct wdt_dw_runtime *context = dev->driver_data;

    if (context->cb_fn) {
        context->cb_fn(dev);
    }
}

static void wdt_dw_get_config(struct device *dev, struct wdt_config *config)
{
    struct wdt_dw_dev_config *wdt_dev = dev->config->config_info;
    struct wdt_dw_runtime *context = dev->driver_data;

    config->timeout = sys_read32(wdt_dev->base_address + WDT_TORR) &
                            WDT_TIMEOUT_MASK;
    config->mode = (sys_read32(wdt_dev->base_address + WDT_CR) & WDT_MODE)
                            >> WDT_MODE_OFFSET;
    config->interrupt_fn = context->cb_fn;
}

static void wdt_dw_reload(struct device *dev)
{
    struct wdt_dw_dev_config *wdt_dev = dev->config->config_info;

    sys_write32(WDT_CRR_VAL, wdt_dev->base_address + WDT_CRR);
}

static int wdt_dw_set_config(struct device *dev, struct wdt_config *config)
{
    struct wdt_dw_dev_config *wdt_dev = dev->config->config_info;
    struct wdt_dw_runtime *context = dev->driver_data;

    sys_write32(config->timeout, wdt_dev->base_address + WDT_TORR);

    /* Set response mode */
    if (WDT_MODE_RESET == config->mode) {
        sys_clear_bit(wdt_dev->base_address + WDT_CR, 1);
    } else {
        if (!config->interrupt_fn) {
            return DEV_FAIL;
        }

        context->cb_fn = config->interrupt_fn;
        sys_set_bit(wdt_dev->base_address + WDT_CR, 1);
    }

    /* Enable WDT, cannot be disabled until soc reset */
    sys_set_bit(wdt_dev->base_address + WDT_CR, 0);

    wdt_dw_reload(dev);

    return DEV_OK;
}

static struct wdt_driver_api wdt_dw_funcs = {
    .set_config = wdt_dw_set_config,
    .get_config = wdt_dw_get_config,
    .enable = wdt_dw_enable,
    .disable = wdt_dw_disable,
    .reload = wdt_dw_reload,
};


#if   0
#define DEVICE_INIT(dev_name, drv_name, init_fn, data, cfg_info, level, prio) \
    \
    static struct device_config __config_##dev_name __used \
    __attribute__((__section__(".devconfig.init"))) = { \
        .name = drv_name, .init = (init_fn), \
        .config_info = (cfg_info) \
    }; \
    \
    static struct device (__device_##dev_name) __used \
    __attribute__((__section__(".init_" #level STRINGIFY(prio)))) = { \
         .config = &(__config_##dev_name), \
         .driver_data = data \
    }


#endif


int wdt_dw_init(struct device *dev);

struct wdt_dw_runtime wdt_runtime;

struct wdt_dw_dev_config wdt_dev = {
    .base_address = CONFIG_WDT_DW_BASE_ADDR,
#ifdef CONFIG_WDT_DW_CLOCK_GATE
    .clock_data = UINT_TO_POINTER(CONFIG_WDT_DW_CLOCK_GATE_SUBSYS),
#endif
};

DEVICE_INIT(wdt, CONFIG_WDT_DW_DRV_NAME, &wdt_dw_init,
            &wdt_runtime, &wdt_dev,
            SECONDARY, CONFIG_KERNEL_INIT_PRIORITY_DEVICE);

int wdt_dw_init(struct device *dev)
{
    dev->driver_api = &wdt_dw_funcs;

    IRQ_CONNECT(CONFIG_WDT_DW_IRQ, CONFIG_WDT_DW_IRQ_PRI, wdt_dw_isr,
            DEVICE_GET(wdt), 0);
    irq_enable(CONFIG_WDT_DW_IRQ);

    _wdt_dw_int_unmask();

    _wdt_dw_clock_config(dev);

    return 0;

}

=========================================================================================

application sample:

#include <zephyr.h>

#include <device.h>
#include <watchdog.h>
#include "board.h"
#include <misc/printk.h>


uint32_t wdt_fired;

#define WDT_DRIVER CONFIG_WDT_DW_DRV_NAME

/* WDT Requires a callback, there is no interrupt enable / disable. */
void wdt_example_cb(struct device *dev)
{
    wdt_fired++;
    printk("watchdog fired\n");
    wdt_reload(dev);
}

void main(void)
{
    struct wdt_config wr_cfg;
    struct wdt_config cfg;
    struct device *wdt_dev;

    printk("Start watchdog test\n");
    wr_cfg.timeout = WDT_2_27_CYCLES;
    wr_cfg.mode = WDT_MODE_INTERRUPT_RESET;
    wr_cfg.interrupt_fn = wdt_example_cb;

    wdt_fired = 0;
    wdt_dev = device_get_binding(WDT_DRIVER);

    wdt_enable(wdt_dev);
    wdt_set_config(wdt_dev, &wr_cfg);

    wdt_get_config(wdt_dev, &cfg);
    printk("timeout: %d\n", cfg.timeout);
    printk("mode: %d\n", cfg.mode);
}

相關推薦

Zephyr Kernel 裝置驅動和裝置模型(二)

   C++語言有封裝、繼承、多型的特點。C語言也可以面向物件和應用設計模式，關鍵就在於如何實現面嚮物件語言的三個重要屬性，下面以watdog為例分析Zephyr裝置驅動和裝置模型。 struct device; /**  * @brief Static device in

裝置、裝置節點和裝置驅動詳解

1.裝置 Linux下的裝置通常分為三類，字元裝置，塊裝置和網路裝置。 裝置驅動程式也分為對應的三類：字元裝置驅動程式、塊裝置驅動程式和網路裝置驅動程式。 常見的字元裝置有滑鼠、鍵盤、串列埠、控制檯等。 常見的塊裝置有各種硬碟、flash磁碟、RAM磁碟等。 在

《物聯網框架ServerSuperIO教程》-19.裝置驅動和OPC Client支援mysql、oracle、sqlite、sqlserver的持久化。v3.6.4版本釋出

19．裝置驅動和OPC Client支援mysql、oracle、sqlite、sqlserver的持久化 19.1     概述      ServerSuperIO支援裝置驅動和OPC Client採集的資料資訊按標籤集合寫入mysql、oracle、sqlserver和sqlite資料庫。現在還支援

Linux驅動開發04：塊裝置驅動和網路裝置驅動

介紹 因為塊裝置驅動和網路裝置驅動實際中用得較少，所以只給出驅動模板，我也沒有具體測試，等到實際用到是再研究吧，溜了溜了。 塊裝置驅動模板 struct xxx_dev { int size; struct request_q

平臺裝置驅動和混雜裝置驅動

1. 平臺裝置驅動 在linux2.6以後的裝置驅動模型中，只關心裝置、驅動和匯流排這三個實體，匯流排將裝置驅動繫結。在向系統註冊一個裝置時會由匯流排匹配對應的驅動，相反當向系統註冊一個驅動時由匯流排匹配出對應的裝置。 在linux裝置和驅動通常要掛接在某條總線上，對於II

裝置樹 --驅動和裝置樹互動過程

在裝置樹中定義的資訊。flash_SY7803:flashlight { compatible = "qcom,leds-gpio-flash"; //匹配引數 status = "okay";

[轉]字元裝置驅動和塊裝置驅動的區…

    系統中能夠隨機（不需要按順序）訪問固定大小資料片（chunks）的裝置被稱作塊裝置，這些資料片就稱作塊。最常見的塊裝置是硬碟，除此以外，還有軟盤驅動器、CD-ROM驅動器和快閃記憶體等等許多其他塊裝置。注意，它們都是以安裝檔案系統的方式使用的——這也是塊裝置的一般訪問方式。 　　另一種基本的裝置型

Android中字元裝置驅動和應用例項(一)——驅動部分

 下面介紹建立Android裝置對應的字元裝置驅動 1 字元驅動 在此示例中，我們將字元驅動新增到drivers/char目錄下。 （1）字元驅動的路徑如下： drivers/char/class_reg_unreg.c （2）字元驅動的內容如下： View C

Linux裝置驅動--塊裝置 之概念和框架

基本概念   塊裝置（blockdevice） --- 是一種具有一定結構的隨機存取裝置，對這種裝置的讀寫是按塊進行的，他使用緩衝區來存放暫時的資料，待條件成熟後，從快取一次性寫入裝置或者從裝置一次性讀到緩衝區。 字元裝置（Character devic

Linux裝置驅動--塊裝置（一）之概念和框架

基本概念   塊裝置（blockdevice） --- 是一種具有一定結構的隨機存取裝置，對這種裝置的讀寫是按塊進行的，他使用緩衝區來存放暫時的資料，待條件成熟後，從快取一次性寫入裝置或者從裝置一次性讀到緩衝區。 字元裝置（Character device） ---是一個順

PCI裝置驅動之裝置

四、PCI裝置的列舉探測過程 在核心啟動過程中，PCI裝置的探測過程是完全自動的，核心已經整合好了方法，我們無需更改，在這裡還是分析一邊程式碼作為了解。 分析之前，先看一下全部的函式呼叫關係，大致瞭解一下 pci_arch_init /* 判斷host/pci

15 核心裡leds-gpio裝置驅動的裝置樹方法

在linux核心裡已提供了連線到gpio的led裝置驅動，只需要通過platform_device或裝置提供相應的硬體資源即可. 使用platform_device方法可參考: http://blog.csdn.net/jklinux/article/deta

Linux 裝置驅動開發 —— 裝置樹在platform裝置驅動中的使用

         關與裝置樹的概念，我們在Exynos4412 核心移植（六）—— 裝置樹解析 裡面已經學習過，下面看一下裝置樹在裝置驅動開發中起到的作用          Device Tree是一種描述硬體的資料結構，裝置樹源(Device Tree Source)檔案

Linux裝置驅動--新增裝置節點

1 環境描述     Host：Ubuntu14.04（64bit）     Target：smdk2410      Kernel：linux-2.6.39.42 前言     我們在剛開始寫Linux裝置驅動程式的時候， 很多時候都是利用mknod命令手動建立裝置節點，

linux裝置驅動--字元裝置驅動

一、linux系統將裝置分為3類：字元裝置、塊裝置、網路裝置。使用驅動程式： 1、字元裝置：是指只能一個位元組一個位元組讀寫的裝置，不能隨機讀取裝置記憶體中的某一資料，讀取資料需要按照先後資料。字元裝置是面向流的裝置，常見的字元裝置有滑鼠、鍵盤、串列埠、控制檯和LE

字元裝置驅動——申請裝置號、註冊字元裝置

1. 裝置號     主裝置號：用來標識與裝置檔案相關的驅動程式，        ——反應裝置型別     次裝置號：為核心所用，被驅動程式用來辨別操作那個裝置檔案    ——區分同類型的具體某個裝置 1.1 裝置號的內部表達     在核心中，儲存裝置號（包括主裝置號和

16 核心裡gpio-keys裝置驅動的裝置樹描述

此裝置驅動在核心裡配置: make menuconfig ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- Device Drivers ---> Input device support

uboot 裝置驅動之裝置驅動描述

include/dm/device.h /**  * struct driver - A driver for a feature or peripheral  *  * This holds methods for setting up a new device, and

裝置驅動模型之：kobject,kset,ktype(二)

之前https://mp.csdn.net/mdeditor/84722837#這個部落格裡面介紹了關於kobject，set，ktype三個結構體之間的關係以及作用，可以做為參考，下面介紹一下這三個結構體相關的函式的使用以及作用； static void kobject_init_in

Linux SPI匯流排和裝置驅動架構之二：SPI通用介面層

通過上一篇文章的介紹，我們知道，SPI通用介面層用於把具體SPI裝置的協議驅動和SPI控制器驅動聯接在一起，通用介面層除了為協議驅動和控制器驅動提供一系列的標準介面API，同時還為這些介面API定義了相應的資料結構，這些資料結構一部分是SPI裝置、SPI協議驅動和SPI控制