Linux gpio驱动学习

蔚落 2022-04-25 03:56 760阅读 0赞

首先我们来看一下gpio驱动框架吧

  1. GPIO驱动的头文件为：include/linux/gpio.h和include/asm-generic/gpio.h。
  2. GPIO驱动框架的实现代码为：drivers/gpio/gpiolib.c。
  4. gpio操作增删改查架构：
  6. /*
  7.  * Add a new chip to the global chips list, keeping the list of chips sorted
  8.  * by base order.
  9.  *
  10.  * Return -EBUSY if the new chip overlaps with some other chip's integer
  11.  * space.
  12.  */
  13. static int gpiochip_add_to_list(struct gpio_chip *chip)
  14. {
  15.     struct list_head *pos;
  16.     struct gpio_chip *_chip;
  17.     int err = 0;
  19.     /* find where to insert our chip */
  20.     list_for_each(pos, &gpio_chips) {
  21.         _chip = list_entry(pos, struct gpio_chip, list);
  22.         /* shall we insert before _chip? */
  23.         if (_chip->base >= chip->base + chip->ngpio)
  24.             break;
  25.     }
  27.     /* are we stepping on the chip right before? */
  28.     if (pos != &gpio_chips && pos->prev != &gpio_chips) {
  29.         _chip = list_entry(pos->prev, struct gpio_chip, list);
  30.         if (_chip->base + _chip->ngpio > chip->base) {
  31.             dev_err(chip->dev,
  32.                    "GPIO integer space overlap, cannot add chip\n");
  33.             err = -EBUSY;
  34.         }
  35.     }
  37.     if (!err)
  38.         list_add_tail(&chip->list, pos);
  40.     return err;
  41. }
  44. int gpiochip_add(struct gpio_chip *chip)
  45. {
  46.     unsigned long    flags;
  47.     int        status = 0;
  48.     unsigned    id;
  49.     int        base = chip->base;
  50.     struct gpio_desc *descs;
  52.     descs = kcalloc(chip->ngpio, sizeof(descs[0]), GFP_KERNEL);
  53.     if (!descs)
  54.         return -ENOMEM;
  56.     spin_lock_irqsave(&gpio_lock, flags);
  58.     if (base < 0) {
  59.         base = gpiochip_find_base(chip->ngpio);
  60.         if (base < 0) {
  61.             status = base;
  62.             spin_unlock_irqrestore(&gpio_lock, flags);
  63.             goto err_free_descs;
  64.         }
  65.         chip->base = base;
  66.     }
  68.     status = gpiochip_add_to_list(chip);
  69.     if (status) {
  70.         spin_unlock_irqrestore(&gpio_lock, flags);
  71.         goto err_free_descs;
  72.     }
  74.     for (id = 0; id < chip->ngpio; id++) {
  75.         struct gpio_desc *desc = &descs[id];
  77.         desc->chip = chip;
  79.         /* REVISIT: most hardware initializes GPIOs as inputs (often
  80.          * with pullups enabled) so power usage is minimized. Linux
  81.          * code should set the gpio direction first thing; but until
  82.          * it does, and in case chip->get_direction is not set, we may
  83.          * expose the wrong direction in sysfs.
  84.          */
  85.         desc->flags = !chip->direction_input ? (1 << FLAG_IS_OUT) : 0;
  86.     }
  88.     chip->desc = descs;
  90.     spin_unlock_irqrestore(&gpio_lock, flags);
  92. #ifdef CONFIG_PINCTRL
  93.     INIT_LIST_HEAD(&chip->pin_ranges);
  94. #endif
  96.     if (!chip->owner && chip->dev && chip->dev->driver)
  97.         chip->owner = chip->dev->driver->owner;
  99.     status = gpiochip_set_desc_names(chip);
  100.     if (status)
  101.         goto err_remove_from_list;
  103.     status = of_gpiochip_add(chip);
  104.     if (status)
  105.         goto err_remove_chip;
  107.     acpi_gpiochip_add(chip);
  109.     status = gpiochip_sysfs_register(chip);
  110.     if (status)
  111.         goto err_remove_chip;
  113.     pr_debug("%s: registered GPIOs %d to %d on device: %s\n", __func__,
  114.         chip->base, chip->base + chip->ngpio - 1,
  115.         chip->label ? : "generic");
  117.     return 0;
  119. err_remove_chip:
  120.     acpi_gpiochip_remove(chip);
  121.     gpiochip_free_hogs(chip);
  122.     of_gpiochip_remove(chip);
  123. err_remove_from_list:
  124.     spin_lock_irqsave(&gpio_lock, flags);
  125.     list_del(&chip->list);
  126.     spin_unlock_irqrestore(&gpio_lock, flags);
  127.     chip->desc = NULL;
  128. err_free_descs:
  129.     kfree(descs);
  131.     /* failures here can mean systems won't boot... */
  132.     pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
  133.         chip->base, chip->base + chip->ngpio - 1,
  134.         chip->label ? : "generic");
  135.     return status;
  136. }
  137. EXPORT_SYMBOL_GPL(gpiochip_add);
  139. /**
  140.  * gpiochip_remove() - unregister a gpio_chip
  141.  * @chip: the chip to unregister
  142.  *
  143.  * A gpio_chip with any GPIOs still requested may not be removed.
  144.  */
  145. void gpiochip_remove(struct gpio_chip *chip)
  146. {
  147.     struct gpio_desc *desc;
  148.     unsigned long    flags;
  149.     unsigned    id;
  150.     bool        requested = false;
  152.     gpiochip_sysfs_unregister(chip);
  154.     gpiochip_irqchip_remove(chip);
  156.     acpi_gpiochip_remove(chip);
  157.     gpiochip_remove_pin_ranges(chip);
  158.     gpiochip_free_hogs(chip);
  159.     of_gpiochip_remove(chip);
  161.     spin_lock_irqsave(&gpio_lock, flags);
  162.     for (id = 0; id < chip->ngpio; id++) {
  163.         desc = &chip->desc[id];
  164.         desc->chip = NULL;
  165.         if (test_bit(FLAG_REQUESTED, &desc->flags))
  166.             requested = true;
  167.     }
  168.     list_del(&chip->list);
  169.     spin_unlock_irqrestore(&gpio_lock, flags);
  171.     if (requested)
  172.         dev_crit(chip->dev, "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
  174.     kfree(chip->desc);
  175.     chip->desc = NULL;
  176. }
  177. EXPORT_SYMBOL_GPL(gpiochip_remove);
  179. /**
  180.  * gpiochip_find() - iterator for locating a specific gpio_chip
  181.  * @data: data to pass to match function
  182.  * @callback: Callback function to check gpio_chip
  183.  *
  184.  * Similar to bus_find_device.  It returns a reference to a gpio_chip as
  185.  * determined by a user supplied @match callback.  The callback should return
  186.  * 0 if the device doesn't match and non-zero if it does.  If the callback is
  187.  * non-zero, this function will return to the caller and not iterate over any
  188.  * more gpio_chips.
  189.  */
  190. struct gpio_chip *gpiochip_find(void *data,
  191.                 int (*match)(struct gpio_chip *chip,
  192.                          void *data))
  193. {
  194.     struct gpio_chip *chip;
  195.     unsigned long flags;
  197.     spin_lock_irqsave(&gpio_lock, flags);
  198.     list_for_each_entry(chip, &gpio_chips, list)
  199.         if (match(chip, data))
  200.             break;
  202.     /* No match? */
  203.     if (&chip->list == &gpio_chips)
  204.         chip = NULL;
  205.     spin_unlock_irqrestore(&gpio_lock, flags);
  207.     return chip;
  208. }
  209. EXPORT_SYMBOL_GPL(gpiochip_find);
  211. static int gpiochip_match_name(struct gpio_chip *chip, void *data)
  212. {
  213.     const char *name = data;
  215.     return !strcmp(chip->label, name);
  216. }
  218. static struct gpio_chip *find_chip_by_name(const char *name)
  219. {
  220.     return gpiochip_find((void *)name, gpiochip_match_name);
  221. }

gpio驱动输入输出设置，高低电平设置：

  1. static int nx_alive_gpio_direction_input(struct udevice *dev, unsigned pin)
  2. {
  3.     struct nx_gpio_platdata *plat = dev_get_platdata(dev);
  4.     struct nx_alive_g+
  5.     pio_regs *const regs = plat->regs;
  7.     setbits_le32(&regs->outputenb_reset, 1 << pin);
  9.     return 0;
  10. }
  12. static int nx_alive_gpio_direction_output(struct udevice *dev, unsigned pin,
  13.                      int val)
  14. {
  15.     struct nx_gpio_platdata *plat = dev_get_platdata(dev);
  16.     struct nx_alive_gpio_regs *const regs = plat->regs;
  18.     if (val)
  19.         setbits_le32(&regs->data, 1 << pin);
  20.     else
  21.         setbits_le32(&regs->pad_reset, 1 << pin);
  23.     setbits_le32(&regs->outputenb, 1 << pin);
  25.     return 0;
  26. }
  28. static int nx_alive_gpio_get_value(struct udevice *dev, unsigned pin)
  29. {
  30.     struct nx_gpio_platdata *plat = dev_get_platdata(dev);
  31.     struct nx_alive_gpio_regs *const regs = plat->regs;
  32.     unsigned int mask = 1UL << pin;
  33.     unsigned int value;
  35.     value = (readl(&regs->pad_read) & mask) >> pin;
  37.     return value;
  38. }
  41. static int nx_alive_gpio_set_value(struct udevice *dev, unsigned pin, int val)
  42. {
  43.     struct nx_gpio_platdata *plat = dev_get_platdata(dev);
  44.     struct nx_alive_gpio_regs *const regs = plat->regs;
  46.     if (val)
  47.         setbits_le32(&regs->data, 1 << pin);
  48.     else
  49.         clrbits_le32(&regs->pad_reset, 1 << pin);
  51.     return 0;
  52. }
  54. static int nx_alive_gpio_get_function(struct udevice *dev, unsigned pin)
  55. {
  56.     struct nx_gpio_platdata *plat = dev_get_platdata(dev);
  57.     struct nx_alive_gpio_regs *const regs = plat->regs;
  58.     unsigned int mask = (1UL << pin);
  59.     unsigned int output;
  61.     output = readl(&regs->outputenb_read) & mask;
  63.     if (output)
  64.         return GPIOF_OUTPUT;
  65.     else
  66.         return GPIOF_INPUT;
  67. }
  69. static int nx_gpio_direction_input(struct udevice *dev, unsigned pin)
  70. {
  71.     struct nx_gpio_platdata *plat = dev_get_platdata(dev);
  72.     struct nx_gpio_regs *const regs = plat->regs;
  74.     if (nx_alive_gpio_is_check(dev))
  75.         return nx_alive_gpio_direction_input(dev, pin);
  77.     clrbits_le32(&regs->outputenb, 1 << pin);
  79.     return 0;
  80. }
  82. static int nx_gpio_direction_output(struct udevice *dev, unsigned pin,
  83.                      int val)
  84. {
  85.     struct nx_gpio_platdata *plat = dev_get_platdata(dev);
  86.     struct nx_gpio_regs *const regs = plat->regs;
  88.     if (nx_alive_gpio_is_check(dev))
  89.         return nx_alive_gpio_direction_output(dev, pin, val);
  91.     if (val)
  92.         setbits_le32(&regs->data, 1 << pin);
  93.     else
  94.         clrbits_le32(&regs->data, 1 << pin);
  96.     setbits_le32(&regs->outputenb, 1 << pin);
  98.     return 0;
  99. }
  101. static int nx_gpio_get_value(struct udevice *dev, unsigned pin)
  102. {
  103.     struct nx_gpio_platdata *plat = dev_get_platdata(dev);
  104.     struct nx_gpio_regs *const regs = plat->regs;
  105.     unsigned int mask = 1UL << pin;
  106.     unsigned int value;
  108.     if (nx_alive_gpio_is_check(dev))
  109.         return nx_alive_gpio_get_value(dev, pin);
  111.     value = (readl(&regs->pad) & mask) >> pin;
  113.     return value;
  114. }
  117. static int nx_gpio_set_value(struct udevice *dev, unsigned pin, int val)
  118. {
  119.     struct nx_gpio_platdata *plat = dev_get_platdata(dev);
  120.     struct nx_gpio_regs *const regs = plat->regs;
  122.     if (nx_alive_gpio_is_check(dev))
  123.         return nx_alive_gpio_set_value(dev, pin, val);
  125.     if (val)
  126.         setbits_le32(&regs->data, 1 << pin);
  127.     else
  128.         clrbits_le32(&regs->data, 1 << pin);
  130.     return 0;
  131. }
  133. static int nx_gpio_get_function(struct udevice *dev, unsigned pin)
  134. {
  135.     struct nx_gpio_platdata *plat = dev_get_platdata(dev);
  136.     struct nx_gpio_regs *const regs = plat->regs;
  137.     unsigned int mask = (1UL << pin);
  138.     unsigned int output;
  140.     if (nx_alive_gpio_is_check(dev))
  141.         return nx_alive_gpio_get_function(dev, pin);
  143.     output = readl(&regs->outputenb) & mask;
  145.     if (output)
  146.         return GPIOF_OUTPUT;
  147.     else
  148.         return GPIOF_INPUT;
  149. }

发表评论

表情：
评论列表 （有 0 条评论，760人围观）

还没有评论，来说两句吧...

相关阅读