Пишем модуль ядра Linux: GPIO с поддержкой IRQ

  • Tutorial
Хабр, привет!

Данная статья посвящена разработке GPIO (General-Purpose Input/Output) модуля ядра Linux. Как и в предыдущей статье мы реализуем базовую структуру GPIO драйвера с поддержкой прерываний (IRQ: Interrupt Request).



Входные данные аналогичны предыдущей статье: разработанный GPIO блок для нового процессора «зашитый» на ПЛИС и запущенный Linux версии 3.18.19.

Для того чтобы разработать GPIO драйвер, нам потребуется выполнить следующие шаги:

  1. Понять принцип взаимодействия GPIO драйвера с user space интерфейсом;
  2. Добавить модуль ядра в сборку и описать аппаратную часть в device tree;
  3. Реализовать базовый скелет драйвера, а также его точки входа и извлечения;
  4. Реализовать функциональную часть GPIO драйвера;
  5. Добавить к реализации драйвера поддержку IRQ.

Примеры GPIO драйверов можно посмотреть тут.

Шаг первый


Для начала познакомимся с принципом взаимодействия GPIO драйвера через консоль пользователя.

С помощью небольшого bash скрипта, создадим в /sysfs элементы управления каждого GPIO. Для этого в командой строке нужно написать следующий скрипт:

for i in {248..255}; do echo $i > /sys/class/gpio/export; done

Далее посмотрим какие возможности предоставляет /sysfs для конфигурации каждого GPIO:

root@zed-slave:/sys/class/gpio# ls -l gpio248/
total 0
-rw-r--r-- 1 root root 4096 Jan  7 20:50 active_low
-rw-r--r-- 1 root root 4096 Jan  7 20:50 direction
-rw-r--r-- 1 root root 4096 Jan  7 20:50 edge
drwxr-xr-x 2 root root    0 Jan  7 20:50 power
lrwxrwxrwx 1 root root    0 Jan  7 20:50 subsystem -> ../../../../class/gpio
-rw-r--r-- 1 root root 4096 Jan  7 20:10 uevent
-rw-r--r-- 1 root root 4096 Jan  7 20:50 value

В данный момент нас интересуют следующие поля:

  • direction — задает направление линии. Может принимать значения «in» или «out»;
  • value — позволяет выставить высокий или низкий сигнал на линии (если direction установлен в «out»), в противном случае (direction установлен в «in») позволяет прочитать состояние линии;
  • edge — позволяет настроить событие по которому происходит прерывание. Может принимать следующие значения: «none», «rising», «falling» или «both».

После беглого знакомства с интерфейсом взаимодействия драйвера через sysfs, можно рассмотреть как драйвер обрабатывает команды пользователя. В ядре Linux есть структура gpio_chip которая описывает функционал gpio контроллера. В ней присутствуют следующие поля:

  • direction_input: настраивает линию на вход. Вызывается при следующей записи: echo «in» > /sys/class/gpio/gpio248/direction;
  • direction_output: настраивает линию на выход. Вызывается при следующей записи: echo «out» > /sys/class/gpio/gpio248/direction;
  • get: считывает установленное на линии значение. Вызывается при следующей записи: cat /sys/class/gpio/gpio248/value;
  • set: устанавливает значение на линии. Вызывается при следующей записи: echo 1/0 > /sys/class/gpio/gpio248/value;

Для описания конфигурации IRQ в Linux существует структура irq_chip, которая содержит следующие поля:

  • irq_set_type: настраивает тип события по которому будет происходить прерывание. Вызывается при следующей записи: echo > «rising»/«falling»/«both» > /sys/class/gpio/gpio248/edge;
  • irq_mask: запрещает прерывания. Вызывается при следующей записи: echo «none» > /sys/class/gpio/gpio248/edge;
  • irq_unmask: разрешает прерывание по событию, которое было установлено в irq_set_type. Вызывается сразу после выполнения irq_set_type.

Шаг второй


Теперь можно добавить драйвер в сборку и описать аппаратную часть, выполнив уже стандартные действия. Первым делом создадим исходный файл:

cd drivers/gpio/
vim gpio-skel.c
:wq

После добавим конфигурацию драйвера в drivers/gpio/Kconfig:

config GPIO_SKEL
	tristate "SKEL GPIO"
	help
	  Say yes here to support SKEL GPIO.

Добавим в сборку драйвер в drivers/gpio/Makefile:

obj-$(CONFIG_GPIO_SKEL)		+= gpio-skel.o

И, наконец, добавим в devicetree (*.dts) описание GPIO блока:

gpio: gpio@f8f01d00 {
	compatible = "skel-gpio";
	rcm,ngpio = <8>;
	rcm,interrupt-type = <IRQ_TYPE_EDGE_RISING>;
	clocks = <&clkc 42>;
	gpio-controller ;
 	interrupt-parent = <&ps7_scugic_0>;
 	interrupts = <0 29 4>;
	reg = <0x43c00000 0x100>;
 } ;

Более подробную информацию про devicetree можно прочитать тут.

Шаг третий


Перейдем к самой интересной для нас части!

Разработку драйвера начнем с подключения необходимых заголовочных файлов и описания полного скелета драйвера без поддержки IRQ. Далее последовательно будем наполнять каждую функцию кодом и сопровождать необходимыми пояснениями.

Скелет драйвера GPIO
/* gpio-skel.c: GPIO driver
 *
 * Name Surname <email>
 *
 * This file is licensed under the terms of the GNU General Public License
 * version 2. This program is licensed "as is" without any warranty of any
 * kind, whether express or implied.
 */

#include <linux/of.h>
#include <linux/irq.h>
#include <linux/io.h>
#include <linux/irqdomain.h>
#include <linux/bitops.h>
#include <linux/irqchip/chained_irq.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/gpio/driver.h>
#include <linux/platform_device.h>

#define SKEL_GPIO_VER			0x04
#define SKEL_GPIO_PAD_DIR		0x08
#define SKEL_GPIO_WR_DATA		0x0C
#define SKEL_GPIO_RD_DATA		0x10
#define SKEL_GPIO_WR_DATA1		0x1C
#define SKEL_GPIO_WR_DATA0		0x20
#define SKEL_GPIO_SRC			0x24

#define SKEL_GPIO_MAX_NGPIO	8

#define GPIO_OFFSET	4

struct skel_gpio_chip {
	struct gpio_chip gchip;
	spinlock_t lock;
	void __iomem *regs;
	u32 type;
};

static inline void gpio_write(uint32_t value, void *base, uint32_t addr)
{
	writel(value, base + addr);
#if defined DEBUG
	dev_dbg(rdev->dev, "iowrite32(0x%x, base + 0x%x);\n", value, addr);
#endif
}

static inline uint32_t gpio_read(void *base, uint32_t addr)
{
	uint32_t reg =  readl(base + addr);
#if defined DEBUG
	dev_dbg(rdev->dev, "/* ioread32(base + 0x%x) == 0x%x */\n", addr, reg);
#endif
	return reg;
}

static inline struct skel_gpio_chip *to_skel_gpio(struct gpio_chip *chip)
{
}

/*
 * echo "in" > /sys/class/gpio/gpioN/direction
 */
static int skel_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
{
}

/*
 * echo "out" > /sys/class/gpio/gpioN/direction
 */
static int skel_gpio_direction_output(struct gpio_chip *chip,
			unsigned offset, int value)
{
}

static int skel_gpio_get(struct gpio_chip *chip, unsigned offset)
{
}

static void skel_gpio_set(struct gpio_chip *chip,
			unsigned offset, int value)
{
}
 
static int skel_gpio_probe(struct platform_device *pdev)
{
}

static int skel_gpio_remove(struct platform_device *pdev)
{
}

static const struct of_device_id skel_gpio_of_match[] = {
	{ .compatible = "skel-gpio" },
	{ },
};

MODULE_DEVICE_TABLE(of, skel_gpio_of_match);

static struct platform_driver skel_gpio_driver = {
	.probe = skel_gpio_probe,
	.remove = skel_gpio_remove,
	.driver = {
		.name = "skel-gpio",
		.of_match_table = of_match_ptr(skel_gpio_of_match),
	},
};

module_platform_driver(skel_gpio_driver);

MODULE_DESCRIPTION("GPIO driver");
MODULE_AUTHOR("Name Surname");
MODULE_LICENSE("GPL");


Как видно из реализации, скелет драйвера выглядит достаточно просто и содержит не так много необходимых функций и структур.

Для того чтобы описать будущий драйвер нам потребуются следующие элементы:

  • platform_driver skel_gpio_driver — описывает точку входа skel_gpio_probe при загрузке драйвера и skel_gpio_remove при его извлечении из ядра;
  • struct of_device_id skel_gpio_of_match — содержит таблицу, которая описывает аппаратную часть GPIO блока;
  • struct skel_gpio_chip — содержит необходимые поля для управления драйвером GPIO блоком.

Далее, чтобы загрузить/извлечь драйвер в/из Linux, необходимо реализовать указанные в структуре skel_gpio_driver методы .probe и .remove.

Реализация skel_gpio_probe
static int skel_gpio_probe(struct platform_device *pdev)
{
	struct device_node *node = pdev->dev.of_node;
	struct skel_gpio_chip *skel_gc;
	struct resource *res;
	int ngpio, ret;

	skel_gc = devm_kzalloc(&pdev->dev, sizeof(*skel_gc), GFP_KERNEL);

	if (!skel_gc)
		return -ENOMEM;

	spin_lock_init(&skel_gc->lock);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (!res) {
		dev_err(&pdev->dev, "Failed to get MMIO resource for GPIO.\n");
		return -EINVAL;
	}

	skel_gc->regs = devm_ioremap_resource(&pdev->dev, res);

	if (!skel_gc->regs)
		goto free;

	if (!of_property_read_u32(node, "skel,ngpio", &ngpio))
		skel_gc->gchip.ngpio = ngpio;
	else
		skel_gc->gchip.ngpio = SKEL_GPIO_MAX_NGPIO;

	if (skel_gc->gchip.ngpio > SKEL_GPIO_MAX_NGPIO) {
		dev_warn(&pdev->dev, "Number of gpio is greater than MAX!\n");
		skel_gc->gchip.ngpio = SKEL_GPIO_MAX_NGPIO;
	}

	skel_gc->gchip.direction_input = skel_gpio_direction_input;
	skel_gc->gchip.direction_output = skel_gpio_direction_output;
	skel_gc->gchip.get = skel_gpio_get;
	skel_gc->gchip.set = skel_gpio_set;
	skel_gc->gchip.owner = THIS_MODULE;
	skel_gc->gchip.base = -1;

	platform_set_drvdata(pdev, skel_gc);

	ret = gpiochip_add(&skel_gc->gchip);

	if (ret) {
		dev_err(&pdev->dev, "Failed adding memory mapped gpiochip\n");
		return ret;
	}

	dev_info(&pdev->dev, "SKEL GPIO probe complete: (%d .. %d)\n",
				skel_gc->gchip.base,
				skel_gc->gchip.base + skel_gc->gchip.ngpio);

	return 0;
}


Реализация skel_gpio_remove
static int skel_gpio_remove(struct platform_device *pdev)
{
	struct skel_gpio_chip *skel_gc = platform_get_drvdata(pdev);

	gpiochip_remove(&skel_gc->gchip);

	return 0;
}


Функция skel_gpio_remove просто удаляет зарегистрированный GPIO драйвер из ядра, поэтому рассмотрим основные моменты в skel_gpio_probe:

  • devm_kzalloc — выделяет память под структуру skel_gpio_chip;
  • platform_get_resource — читает адрес начала регистровой карты GPIO из devicetree;
  • devm_ioremap_resource — выполняет mapping физического адреса на виртуальный;
  • of_property_read_u32 — читает количество доступных GPIO из devicetree;
  • skel_gc->gchip.* — заполняет необходимые для работы поля структуры;
  • gpiochip_add — добавляет GPIO контроллер в драйвер;

До сих пор не было описано почему же используется такие магические числа как 248… 255. Запись skel_gc->gchip.base = -1; просит ядро динамически выделить номера используемых GPIO. Чтобы узнать данные номера в конце драйвера добавлен вывод:

dev_info(&pdev->dev, "SKEL GPIO probe complete: (%d .. %d)\n",
				skel_gc->gchip.base,
				skel_gc->gchip.base + skel_gc->gchip.ngpio);

Конечно, Linux предоставляет возможность задать номера вручную, но давайте посмотрим на комментарий в исходном коде:

@base: identifies the first GPIO number handled by this chip;
 *	or, if negative during registration, requests dynamic ID allocation.
 *	DEPRECATION: providing anything non-negative and nailing the base
 *	offset of GPIO chips is deprecated. Please pass -1 as base to
 *	let gpiolib select the chip base in all possible cases. We want to
 *	get rid of the static GPIO number space in the long run.


Шаг четвертый


Рассмотрим функциональную часть драйвера, а именно реализуем следующие методы:
.direction_output, .direction_input, .get и .set. Далее будет показан аппаратно-зависимый код, который в большинстве случаев будет отличаться.

Реализация skel_gpio_direction_input
/*
 * echo "in" > /sys/class/gpio/gpioN/direction
 */
static int skel_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
{
	struct skel_gpio_chip *gc = to_skel_gpio(chip);
	unsigned long flag;
	u32 data_dir;

	spin_lock_irqsave(&gc->lock, flag);

	data_dir = gpio_read(gc->regs, SKEL_GPIO_PAD_DIR);
	data_dir &= ~BIT(offset);

	gpio_write(data_dir, gc->regs, SKEL_GPIO_PAD_DIR);

	spin_unlock_irqrestore(&gc->lock, flag);

	return 0;
}


Метод skel_gpio_direction_input выполняет следующие действия:

  • Вызывается при следующей команде echo «in» > /sys/class/gpio/gpioN/direction;
  • Считывает регистр SKEL_GPIO_PAD_DIR, который отвечает за установку направления пина GPIO;
  • Устанавливает необходимую маску;
  • Записывает полученное значение обратно в SKEL_GPIO_PAD_DIR.

Реализация skel_gpio_direction_output
/*
 * echo "out" > /sys/class/gpio/gpioN/direction
 */
static int skel_gpio_direction_output(struct gpio_chip *chip,
			unsigned offset, int value)
{
	struct skel_gpio_chip *gc = to_skel_gpio(chip);
	unsigned long flag;
	u32 data_reg, data_dir;

	spin_lock_irqsave(&gc->lock, flag);

	data_reg = gpio_read(gc->regs, SKEL_GPIO_WR_DATA);

	if (value)
		data_reg |= BIT(offset);
	else
		data_reg &= ~BIT(offset);

	gpio_write(data_reg, gc->regs, SKEL_GPIO_WR_DATA);

	data_dir = gpio_read(gc->regs, SKEL_GPIO_PAD_DIR);
	data_dir |= BIT(offset);
	gpio_write(data_dir, gc->regs, SKEL_GPIO_PAD_DIR);

	spin_unlock_irqrestore(&gc->lock, flag);

	return 0;
}


Метод skel_gpio_direction_output выполняет действия аналогичные skel_gpio_direction_inut за исключением того, что вызывается при следующих командах:

  • echo «out» > /sys/class/gpio/gpioN/direction;
  • echo «high» > /sys/class/gpio/gpioN/direction, при этом устанавливает значение value в 1;
  • echo «low» > /sys/class/gpio/gpioN/direction, при этом устанавливает значение value в 0.

value — значение, определяющее уровень сигнала на выходной линии.

Реализация skel_gpio_set
static void skel_gpio_set(struct gpio_chip *chip,
			unsigned offset, int value)
{
	struct skel_gpio_chip *gc = to_skel_gpio(chip);
	unsigned long flag;
	unsigned int data_reg;

	spin_lock_irqsave(&gc->lock, flag);

	data_reg = gpio_read(gc->regs, SKEL_GPIO_WR_DATA);

	if (value)
		data_reg |= BIT(offset);
	else
		data_reg &= ~BIT(offset);

	gpio_write(data_reg, gc->regs, SKEL_GPIO_WR_DATA);

	spin_unlock_irqrestore(&gc->lock, flag);
}


Метод skel_gpio_set выполняет следующие действия:

  • Вызывается при следующей команде echo 1/0 > /sys/class/gpio/gpioN/value;
  • Считывает регистр SKEL_GPIO_WR_DATA, который показывает значение текущего сигнала на линии;
  • Устанавливает или сбрасывает необходимый бит по offset;
  • Записывает полученное значение обратно в SKEL_GPIO_WR_DATA.

Реализация skel_gpio_get
static int skel_gpio_get(struct gpio_chip *chip, unsigned offset)
{
	struct skel_gpio_chip *gc = to_skel_gpio(chip);

	return !!(gpio_read(gc->regs, SKEL_GPIO_RD_DATA) & BIT(offset));
}


Метод skel_gpio_get считывает значение сигнала на линии, прочитав регистр SKEL_GPIO_RD_DATA.

После того как мы описали все необходимые методы и структуры, можно собрать все вместе и взглянуть на итоговый вариант.

Реализация GPIO драйвера
/* gpio-skel.c: GPIO driver
 *
 * Name Surname <email>
 *
 * This file is licensed under the terms of the GNU General Public License
 * version 2. This program is licensed "as is" without any warranty of any
 * kind, whether express or implied.
 */

#include <linux/of.h>
#include <linux/irq.h>
#include <linux/io.h>
#include <linux/irqdomain.h>
#include <linux/bitops.h>
#include <linux/irqchip/chained_irq.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/gpio/driver.h>
#include <linux/platform_device.h>

#define SKEL_GPIO_VER			0x04
#define SKEL_GPIO_PAD_DIR		0x08
#define SKEL_GPIO_WR_DATA		0x0C
#define SKEL_GPIO_RD_DATA		0x10
#define SKEL_GPIO_WR_DATA1		0x1C
#define SKEL_GPIO_WR_DATA0		0x20
#define SKEL_GPIO_SRC			0x24

#define SKEL_GPIO_MAX_NGPIO	8

#define GPIO_OFFSET	4

struct skel_gpio_chip {
	struct gpio_chip gchip;
	spinlock_t lock;
	void __iomem *regs;
	u32 type;
};

static inline void gpio_write(uint32_t value, void *base, uint32_t addr)
{
	writel(value, base + addr);
#if defined DEBUG
	dev_dbg(rdev->dev, "iowrite32(0x%x, base + 0x%x);\n", value, addr);
#endif
}

static inline uint32_t gpio_read(void *base, uint32_t addr)
{
	uint32_t reg =  readl(base + addr);
#if defined DEBUG
	dev_dbg(rdev->dev, "/* ioread32(base + 0x%x) == 0x%x */\n", addr, reg);
#endif
	return reg;
}

static inline struct skel_gpio_chip *to_skel_gpio(struct gpio_chip *chip)
{
	return container_of(chip, struct skel_gpio_chip, gchip);
}

/*
 * echo > "out" > /sys/class/gpio/gpioN/direction
 */
static int skel_gpio_direction_output(struct gpio_chip *chip,
			unsigned offset, int value)
{
	struct skel_gpio_chip *gc = to_skel_gpio(chip);
	unsigned long flag;
	u32 data_reg, data_dir;

	spin_lock_irqsave(&gc->lock, flag);

	data_reg = gpio_read(gc->regs, SKEL_GPIO_WR_DATA);

	if (value)
		data_reg |= BIT(offset);
	else
		data_reg &= ~BIT(offset);

	gpio_write(data_reg, gc->regs, SKEL_GPIO_WR_DATA);

	data_dir = gpio_read(gc->regs, SKEL_GPIO_PAD_DIR);
	data_dir |= BIT(offset);

	gpio_write(data_dir, gc->regs, SKEL_GPIO_PAD_DIR);

	spin_unlock_irqrestore(&gc->lock, flag);

	return 0;
}

/*
 * echo > "in" > /sys/class/gpio/gpioN/direction
 */
static int skel_gpio_direction_input(struct gpio_chip *chip, unsigned offset)

{
	struct skel_gpio_chip *gc = to_skel_gpio(chip);
	unsigned long flag;
	u32 data_dir;

	spin_lock_irqsave(&gc->lock, flag);

	data_dir = gpio_read(gc->regs, SKEL_GPIO_PAD_DIR);
	data_dir &= ~BIT(offset);

	gpio_write(data_dir, gc->regs, SKEL_GPIO_PAD_DIR);

	spin_unlock_irqrestore(&gc->lock, flag);

	return 0;
}

static int skel_gpio_get(struct gpio_chip *chip, unsigned offset)
{
	struct skel_gpio_chip *gc = to_skel_gpio(chip);

	return !!(gpio_read(gc->regs, SKEL_GPIO_RD_DATA) & BIT(offset));
}


static void skel_gpio_set(struct gpio_chip *chip,
			unsigned offset, int value)
{
	struct skel_gpio_chip *gc = to_skel_gpio(chip);
	unsigned long flag;
	unsigned int data_reg;

	spin_lock_irqsave(&gc->lock, flag);

	data_reg = gpio_read(gc->regs, SKEL_GPIO_WR_DATA);

	if (value)
		data_reg |= BIT(offset);
	else
		data_reg &= ~BIT(offset);

	gpio_write(data_reg, gc->regs, SKEL_GPIO_WR_DATA);

	spin_unlock_irqrestore(&gc->lock, flag);
}

static int skel_gpio_remove(struct platform_device *pdev)
{
	struct skel_gpio_chip *skel_gc = platform_get_drvdata(pdev);

	gpiochip_remove(&skel_gc->gchip);

	return 0;
}

static int skel_gpio_probe(struct platform_device *pdev)
{
	struct device_node *node = pdev->dev.of_node;
	struct skel_gpio_chip *skel_gc;
	struct resource *res;
	int ngpio, ret;

	skel_gc = devm_kzalloc(&pdev->dev, sizeof(*skel_gc), GFP_KERNEL);

	if (!skel_gc)
		return -ENOMEM;

	spin_lock_init(&skel_gc->lock);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (!res) {
		dev_err(&pdev->dev, "Failed to get MMIO resource for GPIO.\n");
		return -EINVAL;
	}

	skel_gc->regs = devm_ioremap_resource(&pdev->dev, res);

	if (!skel_gc->regs)
		return -ENXIO;

	if (!of_property_read_u32(node, "skel,ngpio", &ngpio))
		skel_gc->gchip.ngpio = ngpio;
	else
		skel_gc->gchip.ngpio = SKEL_GPIO_MAX_NGPIO;

	if (skel_gc->gchip.ngpio > SKEL_GPIO_MAX_NGPIO) {
		dev_warn(&pdev->dev, "Number of gpio is greater than MAX!\n");
		skel_gc->gchip.ngpio = SKEL_GPIO_MAX_NGPIO;
	}

	skel_gc->gchip.direction_input = skel_gpio_direction_input;
	skel_gc->gchip.direction_output = skel_gpio_direction_output;
	skel_gc->gchip.get = skel_gpio_get;
	skel_gc->gchip.set = skel_gpio_set;
	skel_gc->gchip.owner = THIS_MODULE;
	skel_gc->gchip.base = -1;

	platform_set_drvdata(pdev, skel_gc);

	ret = gpiochip_add(&skel_gc->gchip);

	if (ret) {
		dev_err(&pdev->dev, "Failed adding memory mapped gpiochip\n");
		return ret;
	}

	dev_info(&pdev->dev, "SKEL GPIO probe complete: (%d .. %d)\n",
				skel_gc->gchip.base,
				skel_gc->gchip.base + skel_gc->gchip.ngpio);

	return 0;
}

static const struct of_device_id skel_gpio_of_match[] = {
	{ .compatible = "skel-gpio" },
	{ },
};

MODULE_DEVICE_TABLE(of, skel_gpio_of_match);

static struct platform_driver skel_gpio_driver = {
	.probe = skel_gpio_probe,
	.remove = skel_gpio_remove,
	.driver = {
		.name = "skel-gpio",
		.of_match_table = of_match_ptr(skel_gpio_of_match),
	},
};

module_platform_driver(skel_gpio_driver);

MODULE_DESCRIPTION("GPIO driver");
MODULE_AUTHOR("Name Surname");
MODULE_LICENSE("GPL");


Реализованный драйвер содержит необходимый функционал для управления GPIO, но в данный момент в драйвере отсутствует поддержка работы с прерываниями, поэтому можно перейти к следующему шагу.

Шаг пятый


Добавление IRQ в GPIO драйвер можно разделить на три шага:

  • Описание поддерживаемых методов в структурах данных ядра;
  • Включение поддержки IRQ в момент загрузки драйвера в систему;
  • Реализация поддерживаемых методов.

Первоначально опишем необходимый набор операций:

static struct irq_chip skel_irq_chip = {
	.name = "skel-gpio",
	.irq_mask = skel_gpio_irq_mask,
	.irq_unmask = skel_gpio_irq_unmask,
	.irq_set_type = skel_gpio_irq_set_type,
};

Следовательно драйвер может разрешать(skel_gpio_irq_unmask)/запрещать(skel_gpio_irq_mask) прерывания и указать тип события по которому оно будет генерироваться (skel_gpio_irq_set_type).
Далее опишем единственный метод, который отвечает за сопоставление виртуального irq number с аппаратным.

static struct irq_domain_ops skel_gpio_irq_domain_ops = {
	.map = skel_gpio_irq_domain_map,
};

Затем укажем ядру, что загружаемый драйвер поддерживает работу с IRQ. Для этого необходимо добавить в probe функцию следующий код:

Добавление поддержки IRQ
skel_gc->gchip.to_irq = skel_gpio_to_irq;

skel_gc->domain = irq_domain_add_linear(pdev->dev.of_node,
						rcm_gc->gchip.ngpio,
						&skel_gpio_irq_domain_ops,
						skel_gc);
if (!skel_gc->domain)
	return -ENODEV;

skel_gc->irq = platform_get_irq(pdev, 0);

if (skel_gc->irq < 0)
	goto free;

for (i = 0; i < skel_gc->gchip.ngpio; i++) {
	int irq = rcm_gpio_to_irq(&skel_gc->gchip, i);

	irq_set_chip_and_handler(irq, &skel_irq_chip, handle_simple_irq);
#ifdef CONFIG_ARM
        set_irq_flags(irq, IRQF_VALID);
#else
        irq_set_noprobe(irq);
#endif
	}

irq_set_chained_handler(skel_gc->irq, skel_irq_handler);
irq_set_handler_data(skel_gc->irq, skel_gc);


В выше приведенном коде происходит:

  • Выделение и инициализация области под irq_domain;
  • Считывание номера прерывания с devicetree;
  • mapping между виртуальным и аппаратным прерыванием;
  • Регистрация обработчика прерывания и установка данных на передачу в обработчик;

Приступим к реализации некоторых выше описанных методов.
skel_gpio_to_irq — создает mapping между аппаратным и виртуальным прерыванием. Если же данный mapping уже был создан, то возвращает номер созданного виртуального прерывания.

Реализация skel_gpio_to_irq
static int skel_gpio_to_irq(struct gpio_chip *chip, unsigned gpio)
{
	struct skel_gpio_chip *rcm = to_skel_gpio(chip);

	return irq_create_mapping(rcm->domain, gpio);
}


skel_irq_handler — обработчик прерывания, который:

  • Считывает регистр статуса прерывания;
  • Считывает регистр маски прерывания;
  • Выделяет прерывания ожидающие обработки;
  • Для каждого GPIO в котором возникло прерывание вызывает generic_handle_irq.

Реализация обработчика прерывания
static void skel_irq_handler(unsigned int irq, struct irq_desc *desc)
{
	struct skel_gpio_chip *skel_gc = irq_get_handler_data(irq);
	struct irq_chip *chip = irq_desc_get_chip(desc);
	void __iomem *base;
	u32 status, mask, gpio, pending;

	chained_irq_enter(chip, desc);

	base = skel_gc->regs;

	status = gpio_read(base, SKEL_GPIO_STATUS);
	mask = gpio_read(base, SKEL_GPIO_IRQ_MASK);
	pending = status & mask;

	while (pending) {
		gpio = __ffs(pending);
		pending &= ~BIT(gpio);	

		generic_handle_irq(
				irq_find_mapping(skel_gc->domain, gpio));
	}

	chained_irq_exit(chip, desc);
}


Вот и все, в данной статье мы узнали как происходит взаимодействие GPIO драйвера с виртуальной файловой системой sysfs, реализовали базовую структуру GPIO драйвера, а также рассмотрели методы которые требуются для поддержки IRQ.

В статье не приведена реализация методов skel_gpio_irq_unmask, skel_gpio_irq_mask и skel_gpio_irq_set_type по двум причинам. Во-первых, данные методы просты в реализации. Во-вторых, аппаратно-зависимы. Они отвечают за разрешение или запрет прерываний по определенным событиям, которые поддерживает GPIO контроллер.

Пожалуйста, если вы нашли ошибки/неточности, или вам есть что добавить — напишите в ЛС или в комментарии.

Спасибо за ваше внимание!

Similar posts

AdBlock has stolen the banner, but banners are not teeth — they will be back

More
Ads

Comments 16

    +2
    get: устанавливает полученное значение на линию;
    set: считывает установленное на линии значение.
    тут местами не перепутали?
      0
      Действительно, спасибо!
      0
      Выполняю «Шаг первый»:
      for i in {248..255}; do echo $i > /sys/class/gpio/export; done
      получаю
      bash: echo: write error: Invalid argument

        0
        Добрый день! Вы получаете данную ошибку потому что в вашей системе не зарегестрированы GPIO с такими намерами. Пожалуйста прочитайте конец третьего шага. Прежде чем создавать элементы управления GPIO нужно написать драйвер и узнать номера, которые вы будете создавать использую sysfs.
          –1
          А еще раньше достать такую же железку как у вас…

          То есть стоит написать, что пример не воспроизводим.
            +1
            Данная статья показывает принцип взаимодействия драйвера с sysfs интерфейсом на конкретном примере, а также принцип создание GPIO драйвера с нуля. И так как в драйвере происходит динамическое создание номеров GPIO, это абсолютно предсказуемо, что они будут отличаться. Скорее всего в системе уже существует GPIO драйвер, нужно только узнать правильные номер. Можно изменить диапазон в цикле и тогда вам удасться узнать номера присутсвующих GPIO в системе. Есть еще один вариант: посмотреть на запись gpiochipN, и с большой вероятностью, номера GPIO начинаются с N.
              +1
              1) Если говорить про принцип создание драйвера с нуля, то стоило бы начать с описания железа и его регистров управления.

              2) Если вы затронули тему идентификации gpio, то стоило бы изучить вопрос с наименованием, вы например в курсе, что экспортированный контакт не обязательно будет иметь имя вида gpioN?

              3) Присутвующие в системе gpio надо смотреть исходя из приципиальной схемы и документации. Номера gpio в системе присваиваються по системе «кто первый встал тог и тапки», это раз, во-вторых номера абсолютно не обязательно идут подряд. Тогда уж надо смотреть base для gpiochip и делать экспорт по числу контактов на чипе, для каждого чипа.
                +1
                1) Назначение используемых регистров дается по ходу статьи и так как для каждой платформы будет разная регистровая карта, не стоит загружать читателя ее устройством. Главная цель статьи показать как можно написать драйвер, а не объяснить устройство железа и регистров управления.

                2) У вас каждое предложение с претензиями:) Конечно я в курсе что имена в sysfs не обязательно будут называться gpioN, но только в том случае если реализован данный функционал. В данной статье отсутсвует поддержка задания имени GPIO. Если в статью добавлять все нюансы которые могут быть в GPIO, то статья может очень сильно растянуться. Чего только стоит поддержать PINCTRL для GPIO.

                3) Наверное вы хотите показать, что вы разбираетесь в теме:) Если же у нас достаточно много GPIO, то их разбивают на банки, например: тут. В любом случае, это уже нюансы реализации, а также специфика конкретного чипа, упоминание которых только растянут сатью.

                Данная статья не подробный мануал как написать GPIO драйвер во всех возможных случаях, а лишь отправная точка с которой можно работать и добавлять необходимую вам реализацию в зависимости от платформы с которой вы работаете.

                В любом случае, спасибо за ваши коментарии:)
                  +1
                  Я хорошо разбираюсь в данной теме. Можете почитать мои статьи. Поэтому и делаю замечания, поскольку ваша статья не раскрывает вопрос создания драйвера, можно открыть любой драйвер gpio поверх mmio и мы получим, более внятное представление, как стоит писать gpio драйвер:

                  1) для mmio можно использовать bgpio_init (написанный кстати нашим соотечественником еще аж в 2010 году), и тогда не надо самому писать однотипные в принципе функции write, read, direction и прочие.

                  2) для irq в большинстве случаев сгодится irq_chip_generic

                  3) Их, простите меня, не «разбивают» на банки они уже по банкам находятся.

                  А оправная точка для любого драйвера GPIO, это не подсматривание в готовую реализацию, а вдумчивое изучения документации на железо.
                    0
                    Конечно, отправная точка для создания драйвера, это изучение технической документации, но чтение данной документации не особо поможет вам добавить ваш драйвер в Linux, т.к читатель мог писать драйвера для голого железа, но не иметь опыта работы с Linux.
                    Статья показывает через какие интерфейсы происходит взаимодействие драйвера с ядром Linux и если отрыть директорию в которой содержаться большинство gpio драйверов , то можно увидеть, что они устроены абсолютно также и используют аналогичные интерфейсы. Так что ваше утверждение о том, что статья не расскрывает вопрос создания драйвера, по моему мнению, очень натянуто.
                      0
                      Так что ваше утверждение о том, что статья не расскрывает вопрос создания драйвера, по моему мнению, очень натянуто.

                      То есть вы хотите сказать, что в вашей статье есть что-то новое, что нельзя прочитать в официальной документации?
                      https://www.kernel.org/doc/Documentation/gpio/

                      Тогда уж многое не упомянуто из того, что там уже есть.
                        +1
                        Зачем Вы пристали к человеку? Человек на русском языке расписывает нюансы, изложенные в документации. Статья в любом случае (если написана грамотно) бесценна. Вы оба правы — у вопроса две стороны медали. Автор рассмотрел одну сторону. Вы рассмотрите другую, или Вам слабо потратить время и силы на такую публикацию? Не пойму причин Ваших нападок на автора.
                          0
                          Почему слабо — можете посмотреть:

                          Драйвер виртуальных GPIO с контроллером прерываний на базе QEMU ivshmem для Linux
                          Использование gpio-generic и irq_chip_generic для драйвера gpio
                          Заметка о новом интерфейсе linux kernel — gpio uapi

                          А пристал я потому, что
                          разработанный GPIO блок для нового процессора «зашитый» на ПЛИС

                          Без описания этого блока, данная работа лишена смысла. А что за блок? А он открытый? А скачать можно? А какие типы прерываний поддерживает?

                          А что за процессор?

                          Если все это закрытая разработка, то какой в этом во всем смысл?
                            0
                            Во-первых, да это закрытая разработка, а во-вторых детальное описание не приводится для того, чтобы не привязываться к конкретной платформе.
                            Данная структура драйвера применима к любой платформе и структура драйвера останется неизменной (какой-то функционал конечно может добавляться, но это уже зависит от специфики железки).
                              0
                              Во-первых, да это закрытая разработка, а во-вторых детальное описание не приводится для того, чтобы не привязываться к конкретной платформе.


                              Это очень смелое заявление. Что тогда по-вашему «привязка» к конкретной платформе?
                                0
                                Если вы не против, давайте остановимся на том что каждый по своему прав. Но если хотите, то можем перевести общение в ЛС, чтобы не спорить в комментариях.

      Only users with full accounts can post comments. Log in, please.