GPIO的驅動模型

原創 xw面朝大海 2020-02-23 10:32
  1. 一、概述
  2. GPIO是嵌入式系統最簡單、最常用的資源了，比如點亮LED，控制蜂鳴器，輸出高低電平，檢測按鍵，等等。GPIO分輸入和輸出，在davinci linux中，有關GPIO的最底層的寄存器驅動，\arch\arm\mach-davinci目錄下的gpio.c，這個是寄存器級的驅動，搞過單片機MCU的朋友應該比較熟悉寄存器級的驅動。

  4. GPIO的驅動主要就是讀取GPIO口的狀態，或者設置GPIO口的狀態。就是這麼簡單，但是爲了能夠寫好的這個驅動，在LINUX上作了一些軟件上的分層。爲了讓其它驅動可以方便的操作到GPIO，在LINUX裏實現了對GPIO操作的統一接口，這個接口實則上就是GPIO驅動的框架，具體的實現文件爲gpiolib.c在配置內核的時候，我們必須使用CONFIG_GENERIC_GPIO這個宏來支持GPIO驅動。

  6. GPIO是與硬件體系密切相關的，linux提供一個模型來讓驅動統一處理GPIO，即各個板卡都有實現自己的gpio_chip控制模塊：request, free, input,output, get,set,irq...然後把控制模塊註冊到內核中，這時會改變全局gpio數組：gpio_desc[]. 當用戶請求gpio時，就會到這個數組中找到，並調用這個GPIO對應的gpio_chip的處理函數。gpio實現爲一組可用的 gpio_chip, 由驅動傳入對應 gpio的全局序號去 request, dataout ,datain, free. 這時會調用gpio_chip中具體的實現。
  7. gpio是一組可控件的腳，由多個寄存器同時控制。通過設置對應的寄存器可以達到設置GPIO口對應狀態與功能。數據狀態，輸入輸出方向，清零，中斷（那個邊沿觸發）， 一般是一組（bank）一組的。
  8. 寄存器讀寫函數: __raw_writel() __raw_writeb() __raw_readl() __raw_readb()

  10. 二、linux 中GPIO模型的結構
  11. //表示一個gpio口，含對應的gpio_chip.
  12. //對於每一個gpio，都有一個gpio描述符，這個描述符包含了這個gpio所屬的控制器即chip和一些標誌，label等
  13. struct gpio_desc {
  14.     struct gpio_chip    *chip;
  15.     unsigned long    flags;
  16.     /* flag symbols are bit numbers */
  17.     #define FLAG_REQUESTED 0
  18.     #define FLAG_IS_OUT 1
  19.     #define FLAG_RESERVED 2
  20.     #define FLAG_EXPORT 3 /* protected by sysfs_lock */
  21.     #define FLAG_SYSFS 4 /* exported via /sys/class/gpio/control */
  22.     #define FLAG_TRIG_FALL 5 /* trigger on falling edge */
  23.     #define FLAG_TRIG_RISE 6 /* trigger on rising edge */
  24.     #define FLAG_ACTIVE_LOW 7 /* sysfs value has active low */
  25.     #define FLAG_OPEN_DRAIN 8 /* Gpio is open drain type */
  26.     #define FLAG_OPEN_SOURCE 9 /* Gpio is open source type */
  27.     
  28.     #define ID_SHIFT 16 /* add new flags before this one */ 
  29.     #define GPIO_FLAGS_MASK ((1 << ID_SHIFT) - 1)
  30.     #define GPIO_TRIGGER_MASK (BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))
  31.  
  32. #ifdef CONFIG_DEBUG_FS
  33.     const char    *label;
  34. #endif
  35. };
  36. //採用了一個具有ARCH_NR_GPIOS大小的gpio描述符數組。這個描述符數組便代表了系統所有的gpio。
  37. static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];//ARCH_NR_GPIOS=144,即系統現在有144個GPIO口

  39. //static struct davinci_gpio_controller chips[DIV_ROUND_UP(DAVINCI_N_GPIO, 32)];//將144個GPIO分成每32個一組
  40. //一組GPIO控制器結構，例如GPIO0和GPIO1是一組(共32個GPIO口)，共用一組寄存器，所以GPIO0和GPIO1荷載一起用chips[0]來控制
  41. ///共有144個GPIO，分爲4組（GPIO0~GPIO8），每組有2個banks(即GPIO0和GPIO1爲1組)，每組最多可以有32個GPIO，每組的控制寄存器空間有10個。
  42. struct davinci_gpio_controller {
  43.     struct gpio_chip    chip;//每組對應的gpio_chip
  44.     int            irq_base;//每組對應的中斷
  45.     spinlock_t        lock;//自旋鎖
  46.     void __iomem        *regs;//每組的寄存器地址
  47.     void __iomem        *set_data;//設置數據寄存器地址
  48.     void __iomem        *clr_data;//清除數據寄存器地址
  49.     void __iomem        *in_data;//輸入數據寄存器地址
  50. }; 

  52. //每一個davinci_gpio_controller結構都對應於一個gpio_chip結構，gpio_chip既可看成是davinci_gpio_controller結構的補充
  53. //表示一個gpio controller.通過這個結構抽象化所有的GPIO源，而讓板上其它的模塊可以用相同的接口調用使用這些GPIO。
  54. struct gpio_chip {
  55.     const char    *label;
  56.     struct device    *dev;
  57.     struct module    *owner; 
  58.     int    (*request)(struct gpio_chip *chip,unsigned offset);//請求gpio
  59.     void    *free)(struct gpio_chip *chip,unsigned offset);//釋放gpio
  60.     int    (*get_direction)(struct gpio_chip *chip,unsigned offset);
  61.     int    (*direction_input)(struct gpio_chip *chip,unsigned offset);//配置gpio爲輸入，返回當前gpio狀態
  62.     int    (*get)(struct gpio_chip *chip,unsigned offset);//獲取gpio的狀態
  63.     int    (*direction_output)(struct gpio_chip *chip,unsigned offset, int value);//配置gpio爲輸出，並設置爲value
  64.     int    (*set_debounce)(struct gpio_chip *chip,unsigned offset, unsigned debounce);//設置消抖動時間，尤其是gpio按鍵時有用
  65.     void    (*set)(struct gpio_chip *chip,unsigned offset, int value);//設置gpio爲value值
  66.     int    (*to_irq)(struct gpio_chip *chip,unsigned offset);//把gpio號轉換爲中斷號
  67.     void    (*dbg_show)(struct seq_file *s,struct gpio_chip *chip);
  68.     int    base;// 這個gpio控制器的gpio開始編號
  69.     u16    ngpio;//這個gpio控制器說控制的gpio數
  70.     const char    *const *names;
  71.     unsigned    can_sleep:1;
  72.     unsigned    exported:1;
  73.  
  74. #if defined(CONFIG_OF_GPIO)
  75.     struct device_node *of_node;
  76.     int of_gpio_n_cells;
  77.     int (*of_xlate)(struct gpio_chip *gc,const struct of_phandle_args *gpiospec, u32 *flags);
  78. #endif
  79. #ifdef CONFIG_PINCTRL
  80.     struct list_head pin_ranges;
  81. #endif
  82. };

  84. //GPIO寄存器結構
  85. struct davinci_gpio_regs {
  86.     u32 dir; // gpio方向設置寄存器 
  87.     u32 out_data; // gpio設置爲輸出時，表示輸出狀態(0或1) 
  88.     u32 set_data; // gpio設置爲輸出時，用於輸出高電平 
  89.     u32 clr_data; // gpio設置爲輸出時，用於輸出低電平 
  90.     u32 in_data; // gpio設置爲輸入時，用於讀取輸入值 
  91.     u32 set_rising; // gpio中斷上升沿觸發設置 
  92.     u32 clr_rising; // gpio中斷上升沿觸發清除 
  93.     u32 set_falling; // gpio中斷下降沿觸發設置 
  94.     u32 clr_falling; // gpio中斷下降沿觸發清除 
  95.     u32 intstat; // gpio中斷狀態位，由硬件設置，可讀取，寫1時清除。 
  96. };

  98. struct gpio {
  99.     unsigned gpio;//gpio號
  100.     unsigned long flags;//gpio標誌
  101.     const char *label;//gpio名
  102. };

  104. 三、GPIO的初始化
  105. 1.首先設置GPIO的管腳複用寄存器
  106. static __init void da850_evm_init(void)
  107. {
  108.     //.......
  109.     ret = davinci_cfg_reg_list(da850_gpio_test_pins);
  110.     if (ret) 
  111.         pr_warning("da850_evm_init: gpio test ping mux setup failed: %d\n", ret);
  112.     //.......
  113. }

  115. 2.根據板級結構的資源初始化chips數組，此函數在系統初始化時自動調用
  116. static struct davinci_gpio_controller chips[DIV_ROUND_UP(DAVINCI_N_GPIO, 32)];//將144個GPIO分成每32個一組
  117. static int __init davinci_gpio_setup(void)
  118. {
  119.     int i, base;
  120.     unsigned ngpio;
  121.     struct davinci_soc_info *soc_info = &davinci_soc_info;//板級資源結構
  122.     struct davinci_gpio_regs *regs;

  124.     if (soc_info->gpio_type != GPIO_TYPE_DAVINCI)//判斷GPIO類型
  125.         return 0;

  127.     ngpio = soc_info->gpio_num;//GPIO數量144
  128.     if (ngpio == 0) {
  129.         pr_err("GPIO setup: how many GPIOs?\n");
  130.         return -EINVAL;
  131.     }

  133.     if (WARN_ON(DAVINCI_N_GPIO < ngpio))//DAVINCI_N_GPIO=144
  134.         ngpio = DAVINCI_N_GPIO;

  136.     gpio_base = ioremap(soc_info->gpio_base, SZ_4K);//將GPIO的寄存器物理基地址（#define DA8XX_GPIO_BASE        0x01e26000）映射到內存中
  137.     if (WARN_ON(!gpio_base))
  138.         return -ENOMEM;
  139.     
  140.     //共有144個GPIO，分爲4組（GPIO0~GPIO8），每組有2個banks(即GPIO0和GPIO1爲1組)，每組最多可以有32個GPIO，每組的控制寄存器空間有10個。
  141.     //chips[0]--chips[4],base值爲0,32,64,96,128,ngpio分別爲：32,32,32,32,16
  142.     for (i = 0, base = 0; base < ngpio; i++, base += 32) {
  143.         chips[i].chip.label = "DaVinci";
  144.         //設置操作函數
  145.         chips[i].chip.direction_input = davinci_direction_in;
  146.         chips[i].chip.get = davinci_gpio_get;
  147.         chips[i].chip.direction_output = davinci_direction_out;
  148.         chips[i].chip.set = davinci_gpio_set;

  150.         chips[i].chip.base = base;//每一組開始的GPIO號
  151.         //每組控制的GPIO個數，一般爲32個
  152.         chips[i].chip.ngpio = ngpio - base;
  153.         if (chips[i].chip.ngpio > 32)
  154.             chips[i].chip.ngpio = 32;

  156.         spin_lock_init(&chips[i].lock);
  157.         //找到這組GPIO的寄存器地址，初始化chips結構
  158.         regs = gpio2regs(base);
  159.         chips[i].regs = regs;//設置每組的寄存器
  160.         chips[i].set_data = ?s->set_data;
  161.         chips[i].clr_data = ?s->clr_data;
  162.         chips[i].in_data = ?s->in_data;
  163.         
  164.         gpiochip_add(&chips[i].chip);//註冊gpio_chip
  165.     }
  166.     //chips數組添加到板級資源中
  167.     soc_info->gpio_ctlrs = chips;
  168.     soc_info->gpio_ctlrs_num = DIV_ROUND_UP(ngpio, 32);

  170.     davinci_gpio_irq_setup();//設置GPIO中斷
  171.     return 0;
  172. }
  173. pure_initcall(davinci_gpio_setup);//linux初始化時會自動調用

  175. static struct davinci_gpio_regs __iomem __init *gpio2regs(unsigned gpio)
  176. {
  177.     void __iomem *ptr;
  178.     
  179.     //根據GPIO的基地址累加，其中基地址(gpio_base+0)是REVID(Revision ID Register)寄存器
  180.     //(gpio_base+8)是BINTEN (GPIO Interrupt Per-Bank Enable Register)寄存器
  181.     //所以第一組寄存器從基地址+0x10開始
  182.     if (gpio < 32 * 1)
  183.         ptr = gpio_base + 0x10;
  184.     else if (gpio < 32 * 2)
  185.         ptr = gpio_base + 0x38;
  186.     else if (gpio < 32 * 3)
  187.         ptr = gpio_base + 0x60;
  188.     else if (gpio < 32 * 4)
  189.         ptr = gpio_base + 0x88;
  190.     else if (gpio < 32 * 5)
  191.         ptr = gpio_base + 0xb0;
  192.     else
  193.         ptr = NULL;
  194.     return ptr;
  195. }

  197. int gpiochip_add(struct gpio_chip *chip)
  198. {
  199.     unsigned long    flags;
  200.     int        status = 0;
  201.     unsigned    id;
  202.     int        base = chip->base;
  203.     
  204.     //檢測gpio的有效性，判斷這組GPIO的起始號是否在有效範圍內
  205.     if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))&& base >= 0) {
  206.         status = -EINVAL;
  207.         goto fail;
  208.     }

  210.     spin_lock_irqsave(&gpio_lock, flags);
  211.     
  212.     //如果這組GPIO的起始號小於0，則動態的分配gpio的開始索引。
  213.     if (base < 0) {
  214.         base = gpiochip_find_base(chip->ngpio);//這個函數在gpiolib.c中，在gpio_desc[]中分配chip->ngpio個空間(從最後往前分配)，返回第一個index
  215.         if (base < 0) {
  216.             status = base;
  217.             goto unlock;
  218.         }
  219.         chip->base = base;
  220.     }

  222.     //確保這些分配的gpio號沒有被其他chip佔用
  223.     for (id = base; id < base + chip->ngpio; id++) {
  224.         if (gpio_desc[id].chip != NULL) {
  225.             status = -EBUSY;
  226.             break;
  227.         }
  228.     }
  229.     //填充gpio_desc，將該組內的每個GPIO口的gpio_desc結構和該組的控制結構chip聯繫起來
  230.     if (status == 0) {
  231.         for (id = base; id < base + chip->ngpio; id++) {
  232.             gpio_desc[id].chip = chip;
  233.             gpio_desc[id].flags = !chip->direction_input? (1 << FLAG_IS_OUT): 0;//設置GPIO口標誌
  234.         }
  235.     }
  236.     of_gpiochip_add(chip);

  238. unlock:
  239.     spin_unlock_irqrestore(&gpio_lock, flags);

  241.     if (status)
  242.         goto fail;

  244.     status = gpiochip_export(chip);//與sysfs文件系統有關，這裏不關心
  245.     if (status)
  246.         goto fail;

  248.     return 0;
  249. fail:
  250.     /* failures here can mean systems won't boot... */
  251.     pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",chip->base, chip->base + chip->ngpio - 1,chip->label ? : "generic");
  252.     return status;
  253. }

  255. 四.gpio的申請
  256. //所謂申請就是檢測GPIO描述符desc->flags的FLAG_REQUESTED標誌，已申請的話該標誌是1，否則是0
  257. //往往多個gpio作爲一個數組來進行申請
  258. int gpio_request_array(struct gpio *array, size_t num)
  259. {
  260.     int i, err;

  262.     for (i = 0; i < num; i++, array++) {//遍歷數組中的每一個GPIO，gpio是GPIO號，flags是輸入輸出標誌等，label是其取一個名字
  263.         err = gpio_request_one(array->gpio, array->flags, array->label);
  264.         if (err)
  265.             goto err_free;
  266.     }
  267.     return 0;

  269. err_free:
  270.     while (i--)
  271.         gpio_free((--array)->gpio);
  272.     return err;
  273. }

  275. int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
  276. {
  277.     int err;
  278.     
  279.     //gpio則爲你要申請的哪一個管腳，label則是爲其取一個名字。
  280.     err = gpio_request(gpio, label);
  281.     if (err)
  282.         return err;

  284.     if (flags & GPIOF_DIR_IN)//GPIO標誌是輸入
  285.         err = gpio_direction_input(gpio);//設置管腳爲輸入
  286.     else//GPIO標誌是輸出
  287.         err = gpio_direction_output(gpio,(flags & GPIOF_INIT_HIGH) ? 1 : 0);//根據標誌確定輸出1還是0

  289.     if (err)
  290.         gpio_free(gpio);

  292.     return err;
  293. }

  295. int gpio_request(unsigned gpio, const char *label)
  296. {
  297.     struct gpio_desc    *desc;
  298.     struct gpio_chip    *chip;
  299.     int            status = -EINVAL;
  300.     unsigned long        flags;
  301.     //屏蔽中斷
  302.     spin_lock_irqsave(&gpio_lock, flags);

  304.     if (!gpio_is_valid(gpio))//判斷是否有效，也就是參數的取值範圍判斷
  305.         goto done;
  306.         
  307.     //根據GPIO號找到對應的GPIO描述符結構
  308.     desc = &gpio_desc[gpio];
  309.     chip = desc->chip;//找到該GPIO所在的組控制器
  310.     if (chip == NULL)
  311.         goto done;
  312.         
  313.     //計數加1
  314.     if (!try_module_get(chip->owner))
  315.         goto done;

  317.     //這裏測試並設置flags的第FLAG_REQUESTED位，如果沒有被申請就返回該位的原值0
  318.     if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
  319.         desc_set_label(desc, label ? : "?");//設置GPIO描述符結構desc的label字段
  320.         status = 0;
  321.     } else {
  322.         status = -EBUSY;
  323.         module_put(chip->owner);
  324.         goto done;
  325.     }

  327.     if (chip->request) {/* chip->request may sleep */
  328.         spin_unlock_irqrestore(&gpio_lock, flags);
  329.         status = chip->request(chip, gpio - chip->base);
  330.         spin_lock_irqsave(&gpio_lock, flags);

  332.         if (status < 0) {
  333.             desc_set_label(desc, NULL);
  334.             module_put(chip->owner);
  335.             clear_bit(FLAG_REQUESTED, &desc->flags);
  336.         }
  337.     }

  339. done:
  340.     if (status)
  341.         pr_debug("gpio_request: gpio-%d (%s) status %d\n",gpio, label ? : "?", status);
  342.     spin_unlock_irqrestore(&gpio_lock, flags);
  343.     return status;
  344. }

  346. 五.GPIO的操作
  347. 1.設置GPIO爲輸出或輸入
  348. int gpio_direction_input(unsigned gpio)
  349. {
  350.     unsigned long        flags;
  351.     struct gpio_chip    *chip;
  352.     struct gpio_desc    *desc = &gpio_desc[gpio];
  353.     int            status = -EINVAL;

  355.     spin_lock_irqsave(&gpio_lock, flags);
  356.     
  357.     //判斷GPIO號是否有效
  358.     if (!gpio_is_valid(gpio))
  359.         goto fail;
  360.     //找到GPIO對應的gpio_chip結構
  361.     chip = desc->chip;
  362.     if (!chip || !chip->get || !chip->direction_input)
  363.         goto fail;
  364.     
  365.     //確保此GPIO是在此組內，chip->base是此組GPIO的起始號，chip->ngpio是此組GPIO的個數
  366.     gpio -= chip->base;
  367.     if (gpio >= chip->ngpio)
  368.         goto fail;
  369.         
  370.     //確保GPIO已申請
  371.     status = gpio_ensure_requested(desc, gpio);
  372.     if (status < 0)
  373.         goto fail;

  375.     //到這裏可以確保GPIO是有效的
  376.     spin_unlock_irqrestore(&gpio_lock, flags);

  378.     might_sleep_if(chip->can_sleep);
  379.     //status=0
  380.     if (status) {
  381.         status = chip->request(chip, gpio);
  382.         if (status < 0) {
  383.             pr_debug("GPIO-%d: chip request fail, %d\n",chip->base + gpio, status);
  384.             goto lose;
  385.         }
  386.     }
  387.     //調用底層的已經設置過的操作，這裏即davinci_direction_in
  388.     status = chip->direction_input(chip, gpio);
  389.     if (status == 0)//返回成功
  390.         clear_bit(FLAG_IS_OUT, &desc->flags);//清除輸出標誌
  391. lose:
  392.     return status;
  393. fail:
  394.     spin_unlock_irqrestore(&gpio_lock, flags);
  395.     if (status)
  396.         pr_debug("%s: gpio-%d status %d\n",__func__, gpio, status);
  397.     return status;
  398. }

  400. int gpio_direction_output(unsigned gpio, int value)
  401. {
  402.     //.........GPIO的檢查，同上函數
  403.     
  404.     //調用底層的已經設置過的操作，這裏即davinci_direction_out
  405.     status = chip->direction_output(chip, gpio, value);
  406.     if (status == 0)//返回成功
  407.         set_bit(FLAG_IS_OUT, &desc->flags);//設置輸出標誌
  408. lose:
  409.     return status;
  410. fail:
  411.     spin_unlock_irqrestore(&gpio_lock, flags);
  412.     if (status)
  413.         pr_debug("%s: gpio-%d status %d\n",__func__, gpio, status);
  414.     return status;
  415. }

  417. //根據前邊對gpio_chip結構的初始化，會調用\arch\arm\mach-davinci\gpio.c裏的函數
  418. static int davinci_direction_in(struct gpio_chip *chip, unsigned offset)
  419. {
  420.     return __davinci_direction(chip, offset, false, 0);
  421. }

  423. static int davinci_direction_out(struct gpio_chip *chip, unsigned offset, int value)
  424. {
  425.     return __davinci_direction(chip, offset, true, value);
  426. }

  428. static inline int __davinci_direction(struct gpio_chip *chip,unsigned offset, bool out, int value)
  429. {
  430.     struct davinci_gpio_controller *d = chip2controller(chip);
  431.     struct davinci_gpio_regs __iomem *g = d->regs;//找到此組GPIO的控制寄存器地址
  432.     unsigned long flags;
  433.     u32 temp;
  434.     u32 mask = 1 << offset;

  436.     spin_lock_irqsave(&d->lock, flags);
  437.     temp = __raw_readl(&g->dir);//讀出當前寄存器的輸入輸出方向
  438.     
  439.     if (out) {//爲1設置輸出
  440.         temp &= ~mask;
  441.         __raw_writel(mask, value ? &g->set_data : &g->clr_data);//確定是用於輸出高電平還是輸出低電平
  442.     } 
  443.     else {//爲0設置爲輸入
  444.         temp |= mask;
  445.     }
  446.     __raw_writel(temp, &g->dir);//寫入方向寄存器
  447.     spin_unlock_irqrestore(&d->lock, flags);

  449.     return 0;
  450. }

  452. 2.獲取gpio的狀態
  453. int __gpio_get_value(unsigned gpio)
  454. {
  455.     struct gpio_chip    *chip;

  457.     chip = gpio_to_chip(gpio);
  458.     WARN_ON(chip->can_sleep);
  459.     return chip->get ? chip->get(chip, gpio - chip->base) : 0;//調用davinci_gpio_get
  460. }

  462. static int davinci_gpio_get(struct gpio_chip *chip, unsigned offset)
  463. {
  464.     struct davinci_gpio_controller *d = chip2controller(chip);
  465.     struct davinci_gpio_regs __iomem *g = d->regs;

  467.     return (1 << offset) & __raw_readl(&g->in_data);
  468. }

  470. 3.設置GPIO的值
  471. void __gpio_set_value(unsigned gpio, int value)
  472. {
  473.     struct gpio_chip    *chip;

  475.     chip = gpio_to_chip(gpio);
  476.     WARN_ON(chip->can_sleep);
  477.     chip->set(chip, gpio - chip->base, value);//調用davinci_gpio_set
  478. }

  480. static void davinci_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
  481. {
  482.     struct davinci_gpio_controller *d = chip2controller(chip);
  483.     struct davinci_gpio_regs __iomem *g = d->regs;

  485.     __raw_writel((1 << offset), value ? &g->set_data : &g->clr_data);
  486. }

  488. 六、GPIO驅動編寫
  489. 1.首先要申請GPIO口
  490. 2.註冊設備
  491. 3.創建GPIO的sysfs相關文件
  492. #define GPIO_MAJOR 199         // major device NO.
  493. #define GPIO_MINOR 0         // minor device NO.
  494. #define DEVICE_NAME "omapl138_gpios" /*定義設備驅動的名字，或設備節點名稱*/

  496. #define SET_OUTPUT_LOW 0
  497. #define SET_OUTPUT_HIGH 1
  498. #define GET_VALUE 2
  499. #define SET_INPUT 3

  501. static struct class *gpio_class;
  502. static struct gpio gpio_array[] =
  503. {
  504.     /*{ GPIO_TO_PIN(0, 0), GPIOF_OUT_INIT_LOW,     "RTU_WDI_SIGNAL" },will request fail*/
  505.     { GPIO_TO_PIN(0, 1), GPIOF_OUT_INIT_HIGH, "RTU_PLC_BAK_IO1"}, 
  506.     { GPIO_TO_PIN(0, 2), GPIOF_OUT_INIT_LOW,     "RTU_CHG_EN" }, 
  507.     { GPIO_TO_PIN(0, 3), GPIOF_IN,         "RTU_CHG_PG" }, 
  508.     { GPIO_TO_PIN(0, 5), GPIOF_IN,         "RTU_USB_OC_OUT" }, 
  509.     { GPIO_TO_PIN(0, 6), GPIOF_OUT_INIT_LOW,     "RTU_RUN_IND_LED" },
  510.     { GPIO_TO_PIN(1, 10), GPIOF_IN,         "RTU_TSC_BUSY"},
  511.     { GPIO_TO_PIN(1, 11), GPIOF_IN,        "RTU_PENIRQn" },
  512.     { GPIO_TO_PIN(1, 12), GPIOF_OUT_INIT_LOW, "RTU_uP_Q26x_RESET" }, 
  513.     { GPIO_TO_PIN(1, 13), GPIOF_OUT_INIT_HIGH, "RTU_uP_GPRS_PWR_EN" },
  514.     { GPIO_TO_PIN(1, 14), GPIOF_OUT_INIT_HIGH, "RTU_uP_Q26x_ON/OFF" }, 
  515.     { GPIO_TO_PIN(2, 1), GPIOF_OUT_INIT_LOW, "RTU_PLC_Reset" },
  516.     { GPIO_TO_PIN(2, 2), GPIOF_OUT_INIT_LOW, "RTU_PLC_T_Reg" }, 
  517.     { GPIO_TO_PIN(2, 4), GPIOF_OUT_INIT_LOW, "RTU_PLC_BAK_IO2" },
  518.     { GPIO_TO_PIN(2, 5), GPIOF_OUT_INIT_LOW, "RTU_RS485_RE" }, 
  519.     { GPIO_TO_PIN(2, 15), GPIOF_OUT_INIT_HIGH, "RTU_CHPWR_CS" },
  520.     { GPIO_TO_PIN(3, 9), GPIOF_OUT_INIT_HIGH, "RTU_RS485_DE" }, 
  521.     { GPIO_TO_PIN(6, 1), GPIOF_OUT_INIT_HIGH, "RTU_uP_VPIF_CLKO3" },
  522.     { GPIO_TO_PIN(6, 9), GPIOF_IN,         "RTU_KEY_IN2" },
  523.     { GPIO_TO_PIN(6, 11), GPIOF_IN,        "RTU_ALARM_IN5" },
  524.     { GPIO_TO_PIN(6, 15), GPIOF_OUT_INIT_HIGH,"RTU_uP_RESETOUTn" },
  525. };

  527. static int gpio_open(struct inode *inode,struct file *file)
  528. {
  529.     printk(KERN_WARNING"gpio open success!\n");
  530.     return 0;
  531. }

  533. static int gpio_release(struct inode *inode, struct file *filp)
  534. {
  535.   printk (KERN_ALERT "Device gpio released\n");
  536.   return 0;
  537. }

  539. static int gpio_read(struct file*f,char *dst,size_t size,loff_t*offset)
  540. {
  541.     unsigned char num;
  542.     __copy_to_user(&num,dst,1);
  543. #ifdef DEBUG
  544.      printk("__copy_to_user:%d\n",num);
  545. #endif

  547.     return 0;
  548. }

  550. static int gpio_write(struct file*f,const char *src,size_t size,loff_t *offset)
  551. {
  552.      unsigned char num;
  553.      __copy_from_user(&num,src,1);
  554. #ifdef DEBUG
  555.      printk("__copy_from_user:%d\n",num);
  556. #endif
  557.      return 0;

  559. }

  561. static long gpio_ioctl(struct file *file,unsigned int cmd,unsigned long gpio)
  562. {
  563.     int i;
  564.     unsigned long gpio_num = (gpio/100)*16+gpio%100;
  565.     for (i = 0; i < ARRAY_SIZE(gpio_array); i++) {
  566.         if(gpio_array[i].gpio == gpio_num)
  567.             goto valid_gpio;
  568.     }
  569.     return -1;
  570.         
  571. valid_gpio:
  572.     switch(cmd)//cmd表示應用程序傳入的 GPIO 動作
  573.     {
  574.         case SET_OUTPUT_LOW://0
  575.         {
  576.             gpio_direction_output(gpio_num, 0);
  577.             break;
  578.         }
  579.         case SET_OUTPUT_HIGH://1
  580.         {
  581.             gpio_direction_output(gpio_num, 1);
  582.             break;
  583.         }
  584.         case GET_VALUE://2
  585.         {
  586.             return gpio_get_value(gpio_num);    
  587.         } 
  588.         case SET_INPUT://3
  589.         {
  590.             gpio_direction_input(gpio_num);
  591.             break;
  592.         }
  593.         default:
  594.         {
  595.             printk(KERN_EMERG "GPIO command mistake!!!\n");
  596.             break;
  597.         }
  598.     }
  599.     return 0;
  600. }
  601.         
  602. static const struct file_operations gpio_fops =
  603. {
  604.   .owner = THIS_MODULE,
  605.   .open = gpio_open,
  606.   .release = gpio_release,
  607.   .read = gpio_read,
  608.   .write = gpio_write,
  609.   .unlocked_ioctl = gpio_ioctl,
  610. };

  612. static int __init gpio_init(void) /*內核初始化會調用該函數*/
  613. {
  614.     int ret;
  615.     
  616.     ret = gpio_request_array(gpio_array, ARRAY_SIZE(gpio_array));
  617.     if (ret < 0) 
  618.     {
  619.         printk(KERN_EMERG "GPIO request failed\n");
  620.         goto request_failed; 
  621.     }
  622.     
  623.     dev_t my_dev_no;
  624.     struct cdev *gpio_cdev;
  625.     gpio_cdev = cdev_alloc();
  626.     if(gpio_cdev == NULL)
  627.     {
  628.         printk(KERN_EMERG "Cannot alloc cdev\n");
  629.         goto request_failed;
  630.     }
  631.     cdev_init(gpio_cdev,&gpio_fops);
  632.     gpio_cdev->owner=THIS_MODULE;
  633.     int result=alloc_chrdev_region(&my_dev_no,0,1,DEVICE_NAME); 
  634.     if(result < 0)
  635.     {
  636.         printk(KERN_EMERG "alloc_chrdev_region failed\n");
  637.         goto request_failed;
  638.     }
  639.     ret=cdev_add(gpio_cdev,my_dev_no,1); 
  640.     
  641.     
  642.   ret = register_chrdev(GPIO_MAJOR, DEVICE_NAME, &gpio_fops);//驅動字符設備
  643.      if(ret < 0)
  644.      {
  645.     printk(KERN_EMERG "GPIO register failed\n");
  646.     goto request_failed;
  647.      }
  648.     
  649.     //在sysfs文件系統下創建一個類
  650.   gpio_class = class_create(THIS_MODULE, DEVICE_NAME);
  651.   //device_create-->device_create_vargs-->device_register創建相應的sysfs文件(如dev文件)，用於udev根據sysfs文件系統下的dev文件創建設備節點
  652.     device_create(gpio_class, NULL, MKDEV(GPIO_MAJOR, GPIO_MINOR), NULL, DEVICE_NAME);
  653.     return ret;
  654.     
  655. request_failed:
  656.     gpio_free_array(gpio_array, ARRAY_SIZE(gpio_array)); 
  657.     return ret;
  658. }

  660. static void __exit gpio_exit(void)
  661. {
  662.     device_destroy(gpio_class, MKDEV(GPIO_MAJOR, GPIO_MINOR));
  663.   class_unregister(gpio_class);
  664.   class_destroy(gpio_class);
  665.   unregister_chrdev(GPIO_MAJOR, DEVICE_NAME);
  666. }

  668. module_init(gpio_init);
  669. module_exit(gpio_exit);
  670. MODULE_LICENSE("GPL");
  671. MODULE_VERSION ("v2.0");
  672. MODULE_AUTHOR("wbl <>");
  673. MODULE_DESCRIPTION("OMAPL138 GPIO driver");
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Linux操作系統的安裝策略與過程

【關鍵詞】linux安裝 【提問】如何在不同硬件配置和操作系統環境下成功安裝Linux？ 【文章】Linux操作系統的安裝策略與過程 在現代計算機技術不斷演進的今天，Linux已成爲世界上最流行且功能強大的開源操作系統之一。它不僅廣泛應用於

原創 2024-05-22 01:50:32

想提高閱讀代碼的效率？試試這些工具吧！

前言 程序員間有句名言——“Talk is cheap, show me the code！”源碼的確相較於言語更接近程序真實的狀態，包含了更多的一手信息。因此，無論是剛開始學習代碼的小白還是久經沙場的代碼大神，不管是學習優秀的開源項目

京東雲開發者 2024-06-13 23:54:57

二進制文件查看工具和方法

查看二進制文件可以通過多種方法實現，取決於你想要的具體信息和你使用的操作系統。以下是一些常見的方法和工具： 使用十六進制編輯器 十六進制編輯器可以顯示文件的十六進制表示和對應的ASCII字符。這些工具非常適合查看和編輯二進制文件。 Win

原創 2024-05-30 02:27:38

scp遠程連接複製文件或目錄

文件拷貝 將本地文件拷貝到遠程服務器中 scp 本地文件 遠程服務用戶名@遠程服務器IP地址:指定拷貝到遠程服務器的文件夾路徑 或 scp 本地文件 遠程服務用戶名@遠程服務器名稱:指定拷貝到遠程服務器的文件夾路徑  將遠程服務器

原創 2024-05-30 00:06:48

乾貨收藏！Calico的BGP RouteReflector策略實踐

本文分享自華爲雲社區《Calico BGP RouteReflector策略實踐》，作者：可以交個朋友。 一 背景 容器網絡組件Calico支持多種後端模式，有Overlay的IPIP、Vxlan模式，也有Underlay純路由的BGP模

原創 2024-05-29 22:58:38

centos7按照MYSQL8（安裝包）

查詢Linux的clibc版本 rpm -qa | grep glibc 現在mysql官網找到對應glibc版本的下載url 然後在linux內下載 wget https://dev.mysql.com/get/Downloads

Rsky08 2024-05-29 22:15:17

由淺入深在實踐中玩轉Zabbix，解決剩下20%的監控需求！

本文整理自Zabbix中級認證專家李銘栓（滿分學員）在Zabbix Meetup廣州站的演講。 掌握這幾種監控方式解決80%的監控問題，剩下的20%如何實現？這裏有答案！ 幾點經驗分享： 1

Zabbix中國 2024-05-24 22:33:53

linux加載動態庫失敗

一般我們在Linux下執行某些外部程序的時候可能會提示找不到共享庫的錯誤, 比如: tmux: error while loading shared libraries: libevent-1.4.so.2: cannot open sha

mskk 2024-05-21 00:52:55

Docker on Centos-docker-compose

1、查看網絡 docker network ls docker network inspect $container_name 2、docker-compose微服務庫擴容 前提：application.yml配置文件要做相應調整 dock

原創 2024-05-20 11:27:29

Linux中的tty和pts

一、幾個基本概念 tty（Teletypewriter） 來源於“電傳打印機”，Linux系統中則是終端設備的統稱，同時也代指操作系統中支持終端設備的tty子系統。   console（控制檯）

原創 2024-05-18 00:45:13

個人開發者如何入門 Java 異步編程

標題：《從零開始：一份詳盡的Linux安裝教程》 引言： 在數字化的世界裏，Linux操作系統以其開源的特性、高度的安全性和穩定性，成爲了服務器和個人電腦的熱門選擇。無論是開發者、系統管理員還是技術愛好者，掌握Linux的安裝與配置都是一項

原創 2024-05-17 01:49:09

在Linux操作系統的安裝過程中，如何選擇合適的發行版

【關鍵詞】{{linux安裝}} 【提問】{{question}} 在Linux操作系統的安裝過程中，如何選擇合適的發行版，並確保安裝過程順利進行？此外，對於不同硬件配置的用戶，有哪些特定的安裝注意事項和優化策略？ 【文章】{{Linux操

原創 2024-05-17 01:49:06

流水線 YAML 高級用法來了！大幅降低重複代碼、靈活編排多任務

作者：木煙 在 YAML 化配置流水線時，你是否會遇到以下問題？ 單流水線中批量執行類似任務場景時，YAML 中需要定義多個類似邏輯的 Job，Job 越多，流水線 YAML 配置的越長，YAML 中的重複代碼越多，代碼複用性低，可讀性差

原創 2024-05-16 21:13:44

高效調度新篇章：詳解DolphinScheduler 3.2.0生產級集羣搭建

轉載自tuoluzhe8521 導讀：通過簡化複雜的任務依賴關係， DolphinScheduler爲數據工程師提供了強大的工作流程管理和調度能力。在3.2.0版本中，DolphinScheduler帶來了一系列新功能和改進，使其在生產環

原創 2024-05-15 21:22:54

Spring 按條件裝配使用方法

條件註冊 Spring 4.0 引入條件註冊機制，暴露給用戶的API是@Conditional和Condition接口，把@Conditional聲明在一個 @Component類上，並接受一組條件（Condition實現），容器初始化期間

原創 2024-05-15 11:50:12