카테고리: 리눅스 커널

Sysfs (kobject & kset)

문영일 10 Comments

디바이스 드라이버 모델에서 디바이스들은 하이라키 토플로지 형태로 표현되고 있다.  이렇게 하이라키로 표현된 디바이스 드라이버들은 마운트된 sysfs라는 파일 시스템을 통해 디렉토리 구조로 보여주고 관리된다. 이러한 디바이스 드라이버들의 하이라키 표현을 도와주기 위해 다음 구조체들을 사용한다.

  • kobject
  • kset
  • ktype
  • kref

 

kobject(kernel object)

디바이스들은 여러 가지 객체(구조체)로 표현되는데 이들이 기본적으로 가져야 할 이름과 참조 카운터 및 하이 라키 관계를 표현하기 위해 여러 개의 필드가 필요하다. 리눅스 커널은 이러한 정보 및 하이라키 구성관계를 쉽게 사용할 수 있도록 kobject 구조체를 사용한다.

  • kobject 구조체는 그 자체로는 사용되지 않고 다른 객체(구조체) 내부에 임베드되는 형태로 사용된다.
  • kobject는 이름(name)과 참조 카운터(kref)를 가진다.
  • kobject는 하이라키를 표현하기 위해 부모 kobject 포인터 및 ktype, kset 등을 가진다.
  • kobject는 sysfs 가상 파일 시스템에 디렉토리와 연동되므로 모든 디바이스의 구조를 디렉토리 구조로 표현하고 제어할 수 있다.
    • sysfs 구조에서 하나의 디렉토리는 kobject이다.
  • 관련 API
    • kobject_init()
    • kobject_init_and_add()
    • kobject_register()
    • kobject_add()
    • kobject_rename()
    • kobject_move()
    • kobject_get_path()
    • kobject_set_name()
    • kobject_del()
    • kobject_get()
    • kobject_get_unless_zero()
    • kobject_put()
    • kobject_create_and_add()

 

다음 그림의 좌측을 보면 3개의 객체가 하이라키 구조를 갖는 것을 표현하기 위해 각각 name, kref, parent 등의 멤버가 필요함을 알 수 있다. 이러한 정보를 쉽게 처리하기 위해 화살표 우측과 같이 kobject 구조체를 각 객체에 임베드하여 손쉽게 연동할 수 있음을 알 수 있다.

 

kset(kernel object set)

kobject를 여러개 담을 수 있는 컨테이너이다.

  • kset는 기본적으로 하나의 kobject를 포함한다.
  • kset의 컨테이너 구현은 kobject들이 연결된 리스트이다.
    • 이 리스트에 child kobject들이 연결된다.
  • sysfs에서 하나의 디렉토리 아래에 여러 개의 디렉토리가 필요한 경우 kset을 사용한다.
  • 관련 API
    • kset_register()
    • kset_unregister()
    • kset_find_obj()
    • kset_create_and_add()

 

다음 그림과 같은 디렉토리 구조를 같기 위해서는 디렉토리 밑에 2 개 이상의 child 디렉토리가 포함되어야 한다. 이러한 컨테이너를 구현하기 위해 kobject이외에도 list_lock, list, entry 등의 추가 필드들이 필요함을 알 수 있다. 화살표 우측과 같이 kobject를 포함한 컨테이너를 쉽게 구현할 수 있도록 kset 구조체가 사용됨을 알 수 있다.

 

ktype(kernel object type)

kobject가 제거될 때 호출될 함수가 지정된다. 또한 sysfs를 통해 kobject에 대한 정보를 보여주거나 수정될 때 처리할 오퍼레이션이 지정된다.

  • kobj_type 구조체를 사용한다.
  • kobject의 참조 카운터가 0이되어 더 이상 사용하지 않게될 경우 처리 방법이 지정된다.
    • 디폴트로 kfree() 함수가 호출되어 kobject가 제거된다.
  • sysfs에서 기본적으로 표현되고 수정될 방법이 지정된다.
    • 디폴트로 어트리뷰트에 지정된 show() 후크 함수 및 store() 함수가 지정된다.

 

다음 그림은 kobject가 생성될 때 디폴트 ktype으로 dynamic_kobj_ktype이 가리키는 kobj_type 구조체가 지정되는 것을 보여준다.

 

kref(kernel object reference)

참조 카운터가 kobject에 임베드되어 사용된다.  참조 카운터를 관리하는 표준 API인 kref_*() 함수들을 사용할 수 있다.

  • kobject_get() 함수 호출 시 참조 카운터를 1 증가시키는 kref_get() 함수가 호출된다.
  • kobject_put() 함수 호출 시 참조 카운터를 1 감소시키는 kref_put() 함수가 호출된다.
  • kobject_init() 함수 호출 시 참조 카운터를 1로 초기화시키는 kref_init() 함수가 호출된다.
  • 기타 함수
    • kref_read()
    • kref_get_unless_zero()
    • kref_put_mutex()
    • kref_put_lock()

 

다음 그림은 kobject가 처음 초기화되고 참조 카운터가 1이된 것을 보여준다. 그리고 kobject가 추가된 후 sysfs에 연결된 상태의 kobject 상태 값들을 보여준다.

 

Sysfs 파일시스템

sysfs 파일시스템은 유저가 커널 자료 구조와 인터페이스를 하기 위한 가상파일시스템이다. 디렉토리 및 파일들은 kset, kobject로 표현된다. sysfs는 보통 다음과 같이 마운트된다.

  • mount -t sysfs sysfs /sys

 

sysfs는 최근의 Device Driver Model을 따라 하이라키 관계를 사용하여 관리되는 방법이며 다음 방법들을 대체하는 것을 권고하고 있다.

  • procfs
    • 프로세스 정보를 유저 application과의 인터페이스를 위해 심플하게 readable text 출력 포맷으로 출력하게 고안된 파일 시스템이다.
    • 과도하게 이 디렉토리에 파일들이 모여있는 것을 피하기 위해 sysfs가 사용된다.
  • character 디바이스
    • ioctl()을 포함한 file operation 방식으로 유저 application과의 인터페이스를 수행한다.
    • major 및 minor 넘버링이 필요하다.

 

최신 버전 sysfs

  • sysfs는 앞으로 구조가 대폭 변경된다. sys 디렉토리에 직접 접근해야 하는 low-level 유저 application은 앞으로 몇 가지 rule을 따라야 한다. 앞으로 표준화될 새로운 sysfs의 인터페이스 방법은 다음을 참고한다.

 

sysfs 디렉토리 구조

sysfs의 구조는 대략 다음 그림과 같다.

 

Sysfs 관련 API들

디렉토리
  • sysfs_create_mount_point()
  • sysfs_remove_mount_point()
파일
  • sysfs_notify()
  • sysfs_create_file()
  • sysfs_create_files()
  • sysfs_create_file_ns()
  • sysfs_add_file()
  • sysfs_chmod_file()
  • sysfs_add_file_to_group()
  • sysfs_add_file_mode_ns()
  • sysfs_remove_file_ns()
  • sysfs_remove_files()
  • sysfs_remove_file_from_group()
  • sysfs_create_bin_file()
  • sysfs_remove_bin_file()
그룹
  • sysfs_create_group()
  • sysfs_create_groups()
  • sysfs_update_group()
  • sysfs_remove_group()
  • sysfs_remove_groups()
  • sysfs_merge_group()
  • sysfs_unmerge_group()
  • sysfs_add_link_to_group()
  • sysfs_remove_link_from_group()
  • __compat_only_sysfs_link_entry_to_kobj()
링크
  • sysfs_create_link()
  • sysfs_create_link_nowarn()
  • sysfs_create_link_sd()
  • sysfs_remove_link()
  • sysfs_rename_link_ns()

 

Sysfs 샘플

샘플을 통해 속성을 사용하는 방법과 유저 application으로 이벤트를 전달하는 방법을 알아본다.

 

속성 구조체와 매크로 함수

샘플들을 사용하면서 attribute 및 device_attribute 에 대한 2가지 속성들을 알아보기로한다. bus_attribute, class_attribute 및 driver_attribute 등의 샘플은 사용방법이 유사하므로 생략한다. 다음은 5 가지 속성에 대한 구조체와 관련 매크로 함수들을 보여준다.

  • attribute 구조체
    • __ATTR(_name, _mode, _show, _store)
    • __ATTR_RW(_name)
    • __ATTR_RO(_name)
    • __ATTR_WO(_name)
    • …
  • device_attribute 구조체
    • DEVICE_ATTR(_name, _mode, _show, _store)
    • DEVICE_ATTR_RW(_name)
    • DEVICE_ATTR_RO(_name)
    • DEVICE_ATTR_WO(_name)
    • …
  •  bus_attribute 구조체
    • BUS_ATTR(_name, _mode, _show, _store)
    • BUS_ATTR_RW(_name)
    • BUS_ATTR_RO(_name)
  • class_attribute 구조체
    • CLASS_ATTR_RW(_name)
    • CLASS_ATTR_RO(_name)
    • CLASS_ATTR_WO(_name)
    • …
  • driver_attribute 구조체
    • DRIVER_ATTR_RW(_name)
    • DRIVER_ATTR_RO(_name)
    • DRIVER_ATTR_WO(_name)

 

1) kobject_init() & kobject_add() 사용

Makefile

obj-m := foo1.o foo2.o foo3.o
KER_DIR := /lib/modules/$(shell uname -r)/build

all:
	make -C ${KER_DIR} M=$(PWD) modules
	gcc test.c -o test

clean:
	make -C ${KER_DIR} M=$(PWD) clean
	rm -f test.o
	rm -f test

 

foo.1 샘플은 attribute 구조체를 사용하고 kobject API를 사용하여 /sys/foo/foo_value 및 /sys/foo/foo_notify 속성을 만든다.

foo1.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/kobject.h>
#include <linux/fs.h>
#include <linux/sysfs.h>
#include <linux/string.h>
#include <linux/slab.h>

static struct kobject *foo_kobj;

struct foo_attr{
	struct attribute attr;
	int value;
};

static struct foo_attr foo_value = {
	.attr.name="foo_value",
	.attr.mode = 0644,
	.value = 0,
};

static struct foo_attr foo_notify = {
	.attr.name="foo_notify",
	.attr.mode = 0644,
	.value = 0,
};

static struct attribute * foo_attrs[] = {
	&foo_value.attr,
	&foo_notify.attr,
	NULL
};

static ssize_t foo_show(struct kobject *kobj, struct attribute *attr, char *buf)
{
	struct foo_attr *foo = container_of(attr, struct foo_attr, attr);
	return scnprintf(buf, PAGE_SIZE, "%d\n", foo->value);
}

static ssize_t foo_store(struct kobject *kobj, struct attribute *attr, const char *buf, size_t len)
{
	struct foo_attr *foo = container_of(attr, struct foo_attr, attr);

	sscanf(buf, "%d", &foo->value);
	foo_value.value = foo->value;
	sysfs_notify(foo_kobj, NULL, "foo_notify");
	return len;
}

static struct sysfs_ops foo_ops = {
	.show = foo_show,
	.store = foo_store,
};

static struct kobj_type foo_type = {
	.sysfs_ops = &foo_ops,
	.default_attrs = foo_attrs,
};

static int __init foo_init(void)
{
	int ret = 0;

	printk("%s\n", __func__);

	foo_kobj = kzalloc(sizeof(*foo_kobj), GFP_KERNEL);
	if (!foo_kobj)
	{
		printk("%s: kzalloc() failed\n", __func__);
		return -1;
	}

	kobject_init(foo_kobj, &foo_type);
	ret = kobject_add(foo_kobj, NULL, "%s", "foo");
	if (ret) {
		printk("kobject_add() failed. ret=%d\n", ret);
		kobject_put(foo_kobj);
		foo_kobj = NULL;
	}

	return ret;	/* 0=success */
}

static void __exit foo_exit(void)
{
	if (foo_kobj) {
		kobject_put(foo_kobj);
	}

	printk("%s\n", __func__);
}

module_init(foo_init);
module_exit(foo_exit);
MODULE_LICENSE("GPL");

 

위의 샘플을 동작시키면 다음과 같은 속성 파일이 생성된다.

$ su -
$ insmod foo1.ko
$ cd /sys/foo
$ ls
foo_notify   foo_value
$ echo 123 > foo_value
$ cat foo_value
123
$ rmmod foo1

 

2) kobject_create_and_add() &  sysfs_create_group() 사용

 

foo2.c 샘플은 kobj_attribute 구조체를 사용하고 kobject 및 sysfs API를 사용하여 /sys/foo/foo_value 및 /sys/foo/foo_notify 속성을 만든다. foo2.c의 사용법은 foo1.c와 동일하다.

foo2.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/kobject.h>
#include <linux/fs.h>
#include <linux/sysfs.h>
#include <linux/string.h>
#include <linux/slab.h>

static struct kobject *foo_kobj;

struct foo_attr{
	struct kobj_attribute attr;
	int value;
};

static struct foo_attr foo_value;
static struct foo_attr foo_notify;

static struct attribute *foo_attrs[] = {
	&foo_value.attr.attr,
	&foo_notify.attr.attr,
	NULL
};

static struct attribute_group foo_group = {
	.attrs = foo_attrs,
};

static ssize_t foo_show(struct kobject *kobj, struct kobj_attribute *attr, 
		char *buf)
{
	struct foo_attr *foo = container_of(attr, struct foo_attr, attr);
	return scnprintf(buf, PAGE_SIZE, "%d\n", foo->value);
}

static ssize_t foo_store(struct kobject *kobj, struct kobj_attribute *attr, 
		const char *buf, size_t len)
{
	struct foo_attr *foo = container_of(attr, struct foo_attr, attr);

	sscanf(buf, "%d", &foo->value);
	sysfs_notify(foo_kobj, NULL, "foo_notify");
	return len;
}

static struct foo_attr foo_value = {
	.attr = __ATTR(foo_value, 0644,	foo_show, foo_store),
	.value = 0,
};

static struct foo_attr foo_notify = {
	.attr = __ATTR(foo_notify, 0644, foo_show, foo_store),
	.value = 0,
};

static int __init foo_init(void)
{
	int ret = 0;

	printk("%s\n", __func__);

	foo_kobj = kobject_create_and_add("foo", NULL);
	if (!foo_kobj) {
		printk("%s: kobject_create_and_add() failed\n", __func__);
		return -1;
	}

	ret = sysfs_create_group(foo_kobj, &foo_group);
	if (ret) 
		printk("%s: sysfs_create_group() failed. ret=%d\n", __func__, ret);

	return ret;	/* 0=success */
}

static void __exit foo_exit(void)
{
	if (foo_kobj) {
		kobject_put(foo_kobj);
	}

	printk("%s\n", __func__);
}

module_init(foo_init);
module_exit(foo_exit);
MODULE_LICENSE("GPL");

 

3) platform_device_register() 사용

 

foo3.c 샘플은 플랫폼 디바이스를 등록할 때 device_attribute 구조체를 사용한 디바이스 속성을 등록한다.

foo3.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/kobject.h>
#include <linux/fs.h>
#include <linux/sysfs.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/platform_device.h>                                              

struct foo_attr{
	struct device_attribute attr;
	int value;
};

static struct foo_attr foo_value;
static struct foo_attr foo_notify;

static struct attribute *foo_attrs[] = {
	&foo_value.attr.attr,
	&foo_notify.attr.attr,
	NULL
};

ATTRIBUTE_GROUPS(foo);

static ssize_t foo_show(struct device *dev, struct device_attribute *attr, 
		char *buf)
{
	struct foo_attr *foo = container_of(attr, struct foo_attr, attr);
	return scnprintf(buf, PAGE_SIZE, "%d\n", foo->value);
}

static ssize_t foo_store(struct device *dev, struct device_attribute *attr, 
		const char *buf, size_t len)
{
	struct foo_attr *foo = container_of(attr, struct foo_attr, attr);

	sscanf(buf, "%d", &foo->value);
	sysfs_notify(&dev->kobj, NULL, "foo_notify");
	return len;
}

static struct foo_attr foo_value = {
	.attr = __ATTR(foo_value, 0644, foo_show, foo_store),
	.value = 0,
};

static struct foo_attr foo_notify = {
	.attr = __ATTR(foo_notify, 0644, foo_show, foo_store),
	.value = 0,
};

static struct platform_device foo_device = {                                   
	.name = "foo",
	.id = -1,
	.dev.groups = foo_groups,
};                                                                              

static int __init foo_init(void)
{
	int ret = 0;

	printk("%s\n", __func__);

	ret = platform_device_register(&foo_device);
	if (ret < 0) {
		printk("%s: platform_device_register() failed. ret=%d\n",
				__func__, ret);
		ret = -1;
	}

	return ret;	/* 0=success */
}

static void __exit foo_exit(void)
{
	platform_device_unregister(&foo_device);

	printk("%s\n", __func__);
}

module_init(foo_init);
module_exit(foo_exit);
MODULE_LICENSE("GPL");

 

위의 foo3.c 샘플을 동작시키면 다음과 같이 플랫폼 디비이스 디렉토리 뒤에 foo 플랫폼 디바이스가 만들어지고 그 안에 속성 파일이 생성된다.

$ su -
$ insmod foo3.ko
$ cd /sys/devices/platform/foo
$ ls
driver_override foo_notify foo_value modalias power subsystem uevent
$ echo 123 > foo_value
$ cat foo_value
123
$ rmmod foo3

 

이벤트 테스트를 위한 유저 application

위에서 작성한 3가지의 샘플 모듈을 사용하여 유저 application에서 poll() API를 사용하여 이벤트를 받는 방법을 보여주기 위한 샘플이다.

  • 참고로 커널 모듈에서 속성에 이벤트를 전달하는 방법은 sysfs_notify() 함수를 사용한다.
  • 주의: foo3.c 샘플과 연동하여 테스트하려면 아래 FOO_VALUE 및 FOO_NOTIFY의 디렉토리 경로를 플랫폼 디바이스 위치로 변경해야 한다.
    • #define FOO_VALUE “/sys/devices/platform/foo/foo_value”
    • #define FOO_NOTIFY “/sys/devices/platform/foo/foo_notify”

test.c

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h> 
#include <sys/stat.h> 
#include <poll.h>

#define FOO_VALUE "/sys/foo/foo_value"
#define FOO_NOTIFY "/sys/foo/foo_notify"

int main(int argc, char **argv)
{
	int len, value_fd, notify_fd, recv;
	char attr_data[100];
	struct pollfd fds[1];

	if ((value_fd = open("/sys/foo/foo_value", O_RDWR)) < 0)
	{
		printf("Unable to open %s\n", FOO_VALUE);
		exit(1);
	}

	if ((notify_fd = open("/sys/foo/foo_notify", O_RDWR)) < 0)
	{
		printf("Unable to open %s\n", FOO_NOTIFY);
		exit(1);
	}

	fds[0].fd = notify_fd;
	fds[0].events = POLLPRI | POLLERR;

	/* read garvage data once */
	len = read(notify_fd, attr_data, 100);

	fds[0].revents = 0;

	/* wait until 60 sec */
	recv = poll(fds, 1, 60000);
	if (recv < 0)
	{
		perror("poll error");
	}
	else if (recv == 0)
	{
		printf("Timeout!\n");
	}
	else
	{
		memset(attr_data, 0, 100);
		len = lseek(value_fd, 0, SEEK_SET);
		len = read(value_fd, attr_data, 100);
		printf( "foo_value=%s (len=%d)\n", attr_data, len);
	}

	close(notify_fd);
	close(value_fd);
}

 

다음과 같이 두 개의 터미널을 열고 각각에서 다음과 같이 동작시킨다.

터미널 1
$ su -                 <- 루트 계정으로 접근한다.
$ ./test3              <- 60초 동안 이벤트를 대기한다.
foo_value=456          <- 이벤트가 발생하는 순간 출력된다.
 (len=4)

 

터미널 2
$ su -                         <- 루트 계정으로 접근한다.
$ cd /sys/devices/platform/foo
$ echo 456 > foo_value         <- 이 속성을 변경하는 순간 이벤트가 발생한다.

 

참고

 

GPIO Subsystem -4- (new Interface)

문영일 Leave a comment

 

새로운 GPIO character 디바이스 for User-space

기존 Sysfs 클래스 디바이스 인터페이스

기존 커널의 gpio 디바이스는 클래스 디바이스에 등록되어 관리되었다.

  • “/sys/class/gpio” 디렉토리의 virtual 디렉토리와 파일을 통해 유저 스페이스에서 인터페이스 할 수 있도록 제공한다.
  • 이 인터페이스는 GPIO subsystem core에서 제공한다.
  • gpio 핀 하나 하나에 대응하는 exprot된 가상 디렉토리 및 제어용 파일들이 만들어진다.
  • 추후 사용되지 않을 인터페이스이다. (deprecated)

 

새 character 디바이스 인터페이스

기존 sysfs 클래스 디바이스 기반의 ABI를 사용하는 user-space 인터페이스는 앞으로 character 디바이스로 대체될 예정이다.

  • 매직 넘버를 사용하지 않는 디스커버리(Discovery) 메커니즘을 적용하였다.
  • character 디바이스를 open하여 ioctl()을 통해 gpio 핀 제어가 가능하다.
    • 디바이스 트리에 정의된 line 명에 해당하는 gpio 핀을 ioctl()로 접근하여 제어할 수 있다.
  • 이에 대한 접근 방법은 gpio 유저 application 툴인 커널 디렉토리의 tools/lsgpio.c 파일을 보면 알 수 있다.
  • “/sys/bus/gpio”, “/dev/gpiochipN”
  • 이 새로운 방식은 커널 v4.8부터 사용된다.
    • 관련 유틸리티
      • lsgpio
      • gpio-hammer
      • gpio-event-mon
    • 관련 User 라이브러리 (option)
      • gpiodlib

 

lsgpio

“gpiochip0″명을 가진 gpio controller 디바이스를 open한 후 소속된 gpio 라인명과 사용 상태를 보여준다.

GPIO chip: gpiochip0, "pinctrl-bcm2835", 54 GPIO lines
 line 0: "[SDA0]" unused
 line 1: "[SCL0]" unused
 (...)
 line 16: "STATUS_LED_N" unused
 line 17: "GPIO_GEN0" unused
 line 18: "GPIO_GEN1" unused
 line 19: "NC" unused
 line 20: "NC" unused
 line 21: "CAM_GPIO" unused
 line 22: "GPIO_GEN3" unused
 line 23: "GPIO_GEN4" unused
 line 24: "GPIO_GEN5" unused
 line 25: "GPIO_GEN6" unused
 line 26: "NC" unused
 line 27: "GPIO_GEN2" unused

 

gpio-hammer
$ gpio-hammer --help
gpio-hammer: invalid option -- '-'
Usage: gpio-hammer [options]...
Hammer GPIO lines, 0->1->0->1...
  -n <name>  Hammer GPIOs on a named device (must be stated)
  -o <n>     Offset[s] to hammer, at least one, several can be stated
 [-c <n>]    Do <n> loops (optional, infinite loop if not stated)
  -?         This helptext

Example:
gpio-hammer -n gpiochip0 -o 4
$ gpio-hammer -n gpiochip0 -o 5 -c 2
Hammer lines [5] on gpiochip0, initial states: [1]
[\] [5: 1]

 

gpio-event-mon
$ gpio-event-mon --help
gpio-event-mon: invalid option -- '-'
Usage: gpio-event-mon [options]...
Listen to events on GPIO lines, 0->1 1->0
  -n <name>  Listen on GPIOs on a named device (must be stated)
  -o <n>     Offset to monitor
  -d         Set line as open drain
  -s         Set line as open source
  -r         Listen for rising edges
  -f         Listen for falling edges
 [-c <n>]    Do <n> loops (optional, infinite loop if not stated)
  -?         This helptext

Example:
gpio-event-mon -n gpiochip0 -o 4 -r -f
$ gpio-event-mon -n gpiochip0 -o 6 -r -c 2
Monitoring line 6 on gpiochip0
Initial line value: 1
GPIO EVENT 1527053280817909942: rising edge
GPIO EVENT 1527053282195388044: rising edge

 

New GPIO character 디바이스에 대한 유저 application 샘플 -1-

GPIO character 디바이스 Open 메인

/dev/gpiochipN gpio 디바이스로 open한 후 요청한 gpio 핀 3개를 input, output, input+event 모드로 설정하고 이벤트 입력을 기다린다.

  • 예)  new-gpio-api /dev/gpiochip0 4 5 6

 

new-gpio-api.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/gpio.h>
#include <poll.h>
#include <inttypes.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
        int gpio1, gpio2, gpio3;
        int fd;
        int req_fd;
        int value;
        char * file;

        if (argc < 5) {
                printf("Usage: new-gpio-api /dev/<gpiochipN> "
                                "<in-gpio> <out-gpio> <event-gpio>\n");
                return -1;
        }

        file = argv[1];
        fd = open(file, O_RDWR);
        if (fd < 0) {
                printf("open \"%s\" failed\n", file);
                return -1;
        }

        gpio1 = atoi(argv[2]);
        gpio2 = atoi(argv[3]);
        gpio3 = atoi(argv[4]);

        if (chip_info(fd) < 0)
                goto err;

        if (line_info(fd, gpio1) < 0)
                goto err;

        if (request_gpio(fd, gpio1, GPIOHANDLE_REQUEST_INPUT,
                "foo_input", &req_fd) < 0)
                goto err;

        if (get_value(req_fd, gpio1, &value) < 0)
                goto err;

        if (request_gpio(fd, gpio2, GPIOHANDLE_REQUEST_OUTPUT,
                "foo_output", &req_fd) < 0)
                goto err;

        if (set_value(req_fd, gpio2, 1) < 0)
                goto err;

        if (request_event(fd, gpio3, "foo_event", &req_fd) < 0)
                goto err;

        while (1)
                if (recv_event(req_fd, gpio3) < 0)
                        break;

err:
        close(fd);
        return -1;
}

 

GPIO chip 정보 알아오기

gpio chip 디바이스명, 라벨명, gpio 라인 수를 알아와서 출력한다.

int chip_info(int fd)
{
        int ret;
        struct gpiochip_info cinfo;

        ret = ioctl(fd, GPIO_GET_CHIPINFO_IOCTL, &cinfo);
        if (ret < 0) {
                printf("GPIO_GET_CHIPINFO_IOCTL failed.\n");
                return -1;
        }

        printf("GPIO chip: %s, \"%s\", %u GPIO lines\n",
                cinfo.name, cinfo.label, cinfo.lines);

        return 0;
}

 

GPIO line 정보 알아오기

요청한 gpio 번호로 지정되어 있는 라인명 등을 알아온다.

int line_info(int fd, int gpio)
{
        int ret;
        struct gpioline_info linfo;

        memset(&linfo, 0, sizeof(linfo));
        linfo.line_offset = gpio;

        ret = ioctl(fd, GPIO_GET_LINEINFO_IOCTL, &linfo);
        if (ret < 0) {
                printf("GPIO_GET_LINEINFO_IOCTL failed.\n");
                return -1;
        }

        printf("line %2d: %s\n", linfo.line_offset, linfo.name);

        return fd;
}

 

GPIO line 사용 요청

요청한 gpio 번호에 해당하는 라인을 플래그 값에 해당하는 모드로 설정한다. 라벨명도 지정할 수 있다.

  • flags
    • GPIOHANDLE_REQUEST_INPUT
    • GPIOHANDLE_REQUEST_OUTPUT
int request_gpio(int fd, int gpio, int flags, const char *label, int *req_fd)
{
        struct gpiohandle_request req;
        int ret;

        req.flags = flags;
        req.lines = 1;
        req.lineoffsets[0] = gpio;
        req.default_values[0] = 0;
        strcpy(req.consumer_label, label);

        ret = ioctl(fd, GPIO_GET_LINEHANDLE_IOCTL, &req);
        if (ret < 0) {
                printf("GPIO_GET_LINEHANDLE_IOCTL failed.\n");
                return -1;
        }

        *req_fd = req.fd;

        return 0;
}

 

GPIO line 읽기(Read)

요청한 gpio 번호에 해당하는 라인에서 값(high/low)을 읽어 출력한다.

int get_value(int req_fd, int gpio, int *value)
{
        struct gpiohandle_data data;
        int ret;

        memset(&data, 0, sizeof(data));

        ret = ioctl(req_fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, &data);
        if (ret < 0) {
                printf("GPIO_GET_LINE_VALUES_IOCTL failed.\n");
                return -1;
        }
        printf("line %d is %s\n", gpio, data.values[0] ? "high" : "low");

        *value = data.values[0];

        return 0;
}

 

GPIO line 쓰기(Write)

요청한 gpio 번호에 해당하는 라인에 값(high/low)을 출력한다.

int set_value(int req_fd, int gpio, int value)
{
        struct gpiohandle_data data;
        int ret;

        memset(&data, 0, sizeof(data));
        data.values[0] = value;

        ret = ioctl(req_fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &data);
        if (ret < 0) {
                printf("GPIO_SET_LINE_VALUES_IOCTL failed.\n");
                return -1;
        }
        printf("line %d is %s\n", gpio, data.values[0] ? "high" : "low");

        return 0;
}

 

GPIO line 이벤트 요청

요청한 gpio 번호에 해당하는 라인을 입력 모드로 설정하고 이벤트를 수신할 수 있도록 준비한다.

  • 아래 예에서는 핀에 open drain 설정을 하였고, rising edge 및 falling edge 이벤트에 반응하도록 설정하였다.
int request_event(int fd, int gpio, const char *label, int *req_fd)
{
        struct gpioevent_request req;
        int ret;

        req.lineoffset = gpio;
        strcpy(req.consumer_label, label);
        req.handleflags = GPIOHANDLE_REQUEST_OPEN_DRAIN;
        req.eventflags = GPIOEVENT_REQUEST_RISING_EDGE |
                GPIOEVENT_REQUEST_FALLING_EDGE;

        ret = ioctl(fd, GPIO_GET_LINEEVENT_IOCTL, &req);
        if (ret < 0) {
                printf("GPIO_GET_LINEEVENT_IOCTL failed.\n");
                return -1;
        }

        *req_fd = req.fd;

        return 0;
}

 

GPIO line 이벤트 대기

요청한 gpio 번호에 해당하는 라인에서 이벤트를 수신 대기한다.

#define USE_POLL

int recv_event(int req_fd, int gpio)
{
        struct gpioevent_data event;
        struct pollfd pfd;
        ssize_t rd;
        int ret;

#ifdef USE_POLL
        pfd.fd = req_fd;
        pfd.events = POLLIN | POLLPRI;

        rd = poll(&pfd, 1, 1000);
        if (rd < 0)
        if (ret < 0) {
                printf("poll failed.\n");
                return -1;
        }
#endif
        ret = read(req_fd, &event, sizeof(event));
        if (ret < 0) {
                printf("read failed.\n");
                return -1;
        }

        printf( "GPIO EVENT @%" PRIu64 ": ", event.timestamp);

        if (event.id == GPIOEVENT_EVENT_RISING_EDGE)
                printf("RISING EDGE");
        else
                printf("FALLING EDGE");
        printf ("\n");

        return 0;
}

 

동작 확인

gpio 4, 5, 6번에 대해 다음과 같은 동작을 하는 것을 확인한다.

  • gpio 4번을 입력 모드로 설정하고 low 갑을 읽었다.
  • gpio 5번을 출력 모드로 설정하고 high 출력하였다.
  • gpio 6번을 입력 모드 및 이벤트 수신 대기를 한다.
$ ./new-gpio-api /dev/gpiochip0 4 5 6
GPIO chip: gpiochip0, "0000:00:01.0", 32 GPIO lines
line  4: 
line 4 is low
line 5 is high
GPIO EVENT @1527042559726500338: RISING EDGE                        <- 6번 gpio에 연결된 버튼(high 시그널)을 눌렀을 때

 

아래와 같이 gpio line 4~6 번이 설정되어 동작하는 것을 lsgpio 툴로 확인할 수 있다.

$ lsgpio
GPIO chip: gpiochip0, "0000:00:01.0", 32 GPIO lines
	line  0: unnamed "sysfs" [kernel]
	line  1: unnamed "sysfs" [kernel]
	line  2: unnamed "sysfs" [kernel]
	line  3: unnamed "sysfs" [kernel]
	line  4: unnamed "foo_input" [kernel]
	line  5: unnamed "foo_output" [kernel output]
	line  6: unnamed "foo_event" [kernel open-drain]
	line  7: unnamed unused
	line  8: unnamed unused
	line  9: unnamed unused

 

New GPIO character 디바이스에 대한 유저 application sample -2-

gpiodlib를 사용하는 유저 application 샘플

이 샘플 소스 역시 샘플 1 소스와 동일한 결과를 수행한다.

  • 이 샘플을 빌드하기 위해서는 libgpiod의 설치가 필요하다.

 

libgpiod 다운 및 설치 (for debian)

debian 계열을 사용하는 임베디드에서 테스트하기 위해 root 계정에서 다음과 같이 libgpiod를 설치한다.

$ cd ~
$ apt-get install libtool pkg-config autoconf autoconf-archive
$ git clone https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git
$ cd libgpiod
$ mkdir -p include/linux
$ cp /usr/src/linux-headers-$(uname -r)/include/linux/compiler_types.h include/linux/.
$ ./autogen.sh --enable-tools=yes --prefix=/usr/local CFLAGS="-I/usr/src/linux-headers-$(uname -r)/include/uapi -Iinclude"
$ make
$ make install
$ ldconfig

 

Utility

libgpiod 설치시 같이 제공되는 유틸리티는 다음과 같다.

  • gpiofind
  • gpiodetect
  • gpioinfo
  • gpioget
  • gpiomon
  • gpioset

 

gpiodetect
$ gpiodetect --help
Usage: gpiodetect [OPTIONS]
List all GPIO chips, print their labels and number of GPIO lines.
Options:
  -h, --help:		display this message and exit
  -v, --version:	display the version and exit
$ gpiodetect
gpiochip0 [0000:00:01.0] (32 lines)

 

gpioinfo
$ gpioinfo --help
Usage: gpioinfo [OPTIONS] <gpiochip1> ...
Print information about all lines of the specified GPIO chip(s) (or all gpiochips if none are specified).
Options:
  -h, --help:		display this message and exit
  -v, --version:	display the version and exit

$ gpioinfo gpiochip0
gpiochip0 - 32 lines:
	line   0:      unnamed      "sysfs"   input  active-high [used]
	line   1:      unnamed      "sysfs"   input  active-high [used]
	line   2:      unnamed      "sysfs"   input  active-high [used]
	line   3:      unnamed      "sysfs"   input  active-high [used]
	line   4:      unnamed       unused   input  active-high 
	line   5:      unnamed       unused  output  active-high 
	line   6:      unnamed       unused   input  active-high 
        ...

 

gpioget
$ gpioget --help
Usage: gpioget [OPTIONS] <chip name/number> <offset 1> <offset 2> ...
Read line value(s) from a GPIO chip
Options:
  -h, --help:		display this message and exit
  -v, --version:	display the version and exit
  -l, --active-low:	set the line active state to low

$ gpioget gpiochip0 4
0

 

gpioset
$ gpioset --help
Usage: gpioset [OPTIONS] <chip name/number> <offset1>=<value1> <offset2>=<value2> ...
Set GPIO line values of a GPIO chip
Options:
  -h, --help:		display this message and exit
  -v, --version:	display the version and exit
  -l, --active-low:	set the line active state to low
  -m, --mode=[exit|wait|time|signal] (defaults to 'exit'):
		tell the program what to do after setting values
  -s, --sec=SEC:	specify the number of seconds to wait (only valid for --mode=time)
  -u, --usec=USEC:	specify the number of microseconds to wait (only valid for --mode=time)
  -b, --background:	after setting values: detach from the controlling terminal

Modes:
  exit:		set values and exit immediately
  wait:		set values and wait for user to press ENTER
  time:		set values and sleep for a specified amount of time
  signal:	set values and wait for SIGINT or SIGTERM
$ gpioset gpiochip0 5=1

 

gpiomon
$ gpiomon --help
Usage: gpiomon [OPTIONS] <chip name/number> <offset 1> <offset 2> ...
Wait for events on GPIO lines
Options:
  -h, --help:		display this message and exit
  -v, --version:	display the version and exit
  -l, --active-low:	set the line active state to low
  -n, --num-events=NUM:	exit after processing NUM events
  -s, --silent:		don't print event info
  -r, --rising-edge:	only process rising edge events
  -f, --falling-edge:	only process falling edge events
  -F, --format=FMT	specify custom output format

Format specifiers:
  %o:  GPIO line offset
  %e:  event type (0 - falling edge, 1 rising edge)
  %s:  seconds part of the event timestamp
  %n:  nanoseconds part of the event timestamp
$ gpiomon gpiochip0 6
event:  RISING EDGE offset: 6 timestamp: [1527052928.061198582]

 

샘플 소스 파일

Makefile

LIBGPIOD_DIR=/root/libgpiod/include

all:
	gcc -I. -I$LIBGPIOD_DIR -lgpiod new-gpio-api2.c -o new-gpio-api2 

clean:
	rm -f *.o
	rm -f new-gpio-api2

 

new-gpio-api2.c

#include <stdio.h>
#include "gpiod.h"

int main(int argc, char *argv[])
{
        int gpio1, gpio2, gpio3;
        int fd;
        int req_fd;
        int value;
        char * file;
	int rv;

	struct gpiod_chip *chip;
	struct gpiod_line *line;

	struct timespec ts = { 0, 1000000 };
	struct gpiod_line_event event;
	struct gpiod_line_request_config config;

        if (argc < 5) {
                printf("Usage: new-gpio-api2 /dev/<gpiochipN> "
                                "<in-gpio> <out-gpio> <event-gpio>\n");
                return -1;
        }

        file = argv[1];

        gpio1 = atoi(argv[2]);
        gpio2 = atoi(argv[3]);
        gpio3 = atoi(argv[4]);

	chip = gpiod_chip_open(file);
	if (!chip)
		return -1;

	/* foo-input */
	line = gpiod_chip_get_line(chip, gpio1);
	if (!line) 
		goto err;

	rv = gpiod_line_request_input(line, "foo-input2");
	if (rv)
		goto err;

	value = gpiod_line_get_value(line);

	/* foo-output */
	line = gpiod_chip_get_line(chip, gpio2);
	if (!line)
		goto err;

	rv = gpiod_line_request_output(line, "foo-output2", 0);
	if (rv)
		goto err;

	gpiod_line_set_value(line, 1);

	line = gpiod_chip_get_line(chip, gpio3);
	if (!line)
		goto err;

	rv = gpiod_line_request_rising_edge_events_flags(line, "foo-event2", 
			GPIOD_LINE_REQUEST_FLAG_OPEN_DRAIN);
	if (rv) 
		goto err;

	while (1)
	{
		do {
			rv = gpiod_line_event_wait(line, &ts);
		} while (rv <= 0);

		rv = gpiod_line_event_read(line, &event);
	}

err:
	gpiod_chip_close(chip);

	return -1;
}

 

참고

 

 

QEMU 에뮬레이션(arm64)

문영일 Leave a comment

PC 환경에서 arm64 커널을 에뮬레이션해보자.

 

목적

사용자 OS로 64bit x86 PC Window 환경에서 virtualbox를 사용하여 호스트 OS용도로 우분투 리눅스를 사용하고 있는데, 이 우분투에서 QEMU를 사용하여 게스트 OS로 arm64 커널을 사용하게 한다.

  • 게스트 OS로 arm 연합인 Linaro에서 안정적으로 제공하는 커널인 LSK(Linaro Stable Kernel) 커널을 사용한다. 그리고 Linaro Releases 사이트에서 같이 제공하는 여러 가지 형태의 루트파일시스템을 사용한다.
  • 게스트 OS에서 인터넷이 동작해야 한다.
  • 게스트 OS에서 gcc 컴파일 환경이 있어야 한다.

 

테스트 환경 조건

  • 사용자 OS
    • x86 아키텍처(intel 64bit)를 사용하는 PC
    • Window 8 또는 10 (반드시 64비트 운영체제여야 함)
    • 호스트 OS로 리눅스를 사용하기 위해 VirutalBox 5.1 사용
  • 호스트 OS
    • Ubuntu 64bit 14.04 이상 (반드시 64비트 운영체제여야 함)
    • QEMU 2.9 이상
  • 게스트 OS (arm64)
    • LSK 4.4 이상
      • LSK 4.14 추천

 

사전 준비 작업

다음 항목들이 사전에 준비되어 있어야 한다. 이 항목들의 설치 방법은 설명하지 않는다.

  • 64bit Windows 10
  • VirtualBox 5.1
  • 64bit Ubuntu 14.4 이상
    • kernel 4.14 이상의 빌드환경을 위해서는 Ubuntu 64bit 18.04 권장
  • Linaro 툴체인 5.3 이상
    • Ubuntu 18.04의 경우 gcc 7.3 권장
  • gcc 컴파일러 4.8.4
    • Ubuntu 18.04의 경우 gcc 7.3 권장
  • QEMU 2.9 이상
    • Guest OS 실행 시 콘솔 출력이 안되는 경우 qemu 소스를 다운로드 및  빌드 후 설치 권장
    • Ubuntu 18.04의 경우 QEMU 2.11 권장
  • 기타 툴 (각자 호스트 OS 환경에 맞춰…)
    • gawk wget git-core diffstat unzip texinfo gcc-multilib build-essential chrpath socat libsdl1.2-dev xterm lib32stdc++6 lib32z1 libssl-dev device-tree-compiler vim autogen autoconf libtool flex bison ncurses-dev uuid-dev python-dev python-crypto libsdl2-dev libbsd libattr-devel screen qemu-utils cloud-utils bridge-utils dnsmasq uml-utilities

 

에뮬레이션 모드 vs VM 가속화 모드(KVM)

QEMU는 에뮬레이션 모드와 VM 가속화 모드가 있다는 것을 미리 알아두어야 혼동이되지 않는다.

  • 에뮬레이션 모드
    • 호스트 OS용 아키텍처와 게스트 OS용 아키텍처 코드를 실행할 수 있다.
    • 예: x86 pc 호스트 환경에서 aarch64 커널을 구동
  • 가속화 모드(KVM 모드)
    • “–kvm” 플래그를 사용하여 호스트와 게스트 os가 동일한 아키텍처인 경우 VM을 가속화할 수 있다.
    • 예: aarch64 호스트(임베디드 등) 환경에서 arm64 커널(aarch64) 구동

 

1. VirtualBox 주요 네트워크 설정

 

네트웍 환경

QEMU를 사용하면서 가장 어려운 설정이 네트워크 부분이다. 다음 그림과 같은 네트워크 환경으로 구성할 예정이다.

  • 여러 가지 제약 조건이 걸려있기 때문에 잘 이해하고 준비해두어야 한다.

 

VirtualBox 환경 설정

아래 그림과 같이 VirtualBox에 NAT 네트워크를 20.0.2.0/24 네트워크 대역으로 만든다.

  • VirtualBox의 default NAT 네트워크 대역은 10.0.2.x/24를 사용하는데 이를 변경하여 20.0.2.x/24 대역을 사용한다.
  • 인터넷 연결이 제한된 호스트 전용 네트워크는 구성하지 않는다.

 

VirtualBox에서 Ubuntu OS 네트워크 설정

64비트용 우분투 OS의 네트워크 설정을 다음과 같이 변경한다.

 

Ubuntu 부팅 후 네트워크 설정

호스트 OS인 우분투 버전에 따라 NIC 인터페이스 이름이 아래 둘 중 하나로 결정된다.
  • eth0
  • enp0s3 (우분투 15.10 이상부터 적용)
네트워크 설정을 관리하는 방법은 다음 두 가지가 있는데 여기에서는 /etc/network/interface를 사용한다.
  • /etc/network/interface (전통적 방법)
  • Network Manager

 

/etc/network/interfaces 파일 수정

호스트 OS의 브리지 설정 및 NAT forwading을 위해 /etc/network/interface 파일을 다음과 같이 수정한다.

  • 게스트 OS를 위한 promisc 설정
    • enp0s3(eth0) 인터페이스에 반드시 PROMISC가 설정되어 있어야 bridge 내에 추가되는 tap0 인터페이스에 enp0s3로 수신되는 모든 패킷을 tap 인터페이스도 브릿지되어 전달될 수 있도록 한다.
    • 만일 promisc가 enp0s3(eth0)에 설정되지 않은 경우 enp0s3가 수신한 패킷 중 dest MAC이 enp0s3의 MAC이 아닌 경우 filter 처리하므로 게스트 OS의 네트웍 드라이버에서 사용하는 MAC이 tap0를 통해 수신할 수 없다.
      • 게스트 OS가 자신의 패킷을 전송할 수는 있어도 자신에게 오는 인터넷 패킷을 수신할 수 없다.
  • 게스트 OS를 위한 NAT 설정
    • 아래 스크립트의 가장 마지막 두 줄에 해당한다.
$ sudo vi /etc/network/interfaces
auto lo
iface lo inet loopback

auto enp0s3
iface enp0s3 inet manual
    address 0.0.0.0
    netmask 255.255.255.0

auto virbr0
iface virbr0 inet static
        address 20.0.2.4
        netmask 255.255.255.0
        gateway 20.0.2.2
        bridge_ports enp0s3
        bridge_stp off

up /sbin/ifconfig enp0s3 promisc
up sysctl net.ipv4.ip_forward=1
up iptables -t nat -A POSTROUTING -o virbr0 -j MASQUERADE

 

Network Manager 동작 정지

네트워크 매니저가 동작하지 못하게  /etc/NetworkManager/NetworkManager.conf 파일을 다음과 같이 수정한다.

  • managed=false와 같이 수정한다.
$ sudo vi /etc/NetworkManager/NetworkManger.conf
[main]
plugins=ifupdown,keyfile,ofono
dns=dnsmasq

no-auto-default=08:00:27:15:4C:52,

[ifupdown]
managed=false

 

DNS Server 설정

최근에는 dns 설정을 위해 /etc/resolv.conf 파일의 직접적인 수정은 허용하지 않는다. 따라서 다음과 같은 동작을 수행한다.

  • 아래 예에서는 dns server로 168.126.63.1을 사용하였다. (적절히 사용자가 선호하는 dns server를 1개 이상 등록한다)
$ sudo vi /etc/resolvconf/resolv.conf.d/tail
nameserver 168.126.63.1

$ sudo service resolvconf restart

 

등록이 잘 되었는지 확인해본다.

$ cat /etc/resolv.conf
nameserver 127.0.0.1
nameserver 168.126.63.1

 

호스트 OS 네트웍 테스트

다음과 같이 우분트를 리부팅한 후 네트웍이 정상 동작하는지 확인한다.

$ sudo reboot

   (리부팅)

$ ifconfig
enp0s3    Link encap:Ethernet  HWaddr 08:00:27:59:bc:f3  
          UP BROADCAST RUNNING PROMISC MULTICAST  MTU:1500  Metric:1
          ...
virbr0    Link encap:Ethernet  HWaddr 08:00:27:59:bc:f3  
          inet addr:20.0.2.4  Bcast:20.0.2.255  Mask:255.255.255.0
          inet6 addr: fe80::a00:27ff:fe59:bcf3/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          ...
$ route
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         20.0.2.2        0.0.0.0         UG    0      0        0 virbr0
20.0.2.0        *               255.255.255.0   U     0      0        0 virbr0
link-local      *               255.255.0.0     U     1000   0        0 virbr0

$ ping hello.net
PING hello.net (52.216.83.66) 56(84) bytes of data.
64 bytes from 52.216.83.66: icmp_seq=1 ttl=37 time=186 ms
64 bytes from 52.216.83.66: icmp_seq=2 ttl=37 time=187 ms

 

탭(tap) 인터페이스 생성

게스트 OS가 호스트 OS와의 통신 뿐만 아니라 외부 인터넷망과 연동하려면 tap 인터페이스를 준비하여야 한다.

 

탭 인터페이스 생성 스크립트 준비

호스트 OS에 tap0 인터페이스를 만들고 브리지에 등록하는 스크립트를 준비한다.

  • 호스트 OS 버전에 따라 이더넷 인터페이스 명이 달라지므로 아래 ENET 변수를 사용하는 호스트 이더넷 인터페이스명에 맞게 수정한다.
    • enp0s3 (우분투 15.04 이상)
    • eth0
  • 호스트 OS 커널이 tap 인터페이스를 만들 수 있도록 tun 디바이스가 준비되어 있어야 한다.
    • 확인: 호스트 OS인 우분투에 /dev/net/tun 파일이 존재해야 한다.
  • 주의: tap0 인터페이스는 사용자 권한에서 접근이 가능해야 하므로 현재 사용자명을 사용하여 생성한다.
    • 아래 스크립트에서 sudo tunctl -u {WHOAMI} 부분을 참고한다.
$ mkdir qq2
$ cd qq2
$ vi tap.sh
WHOAMI=$(whoami)

echo add tap0 to virbr0 bridge
echo ------------------------------------------------------
sudo tunctl -d tap0
sudo tunctl -u ${WHOAMI}
sudo ifconfig tap0 0.0.0.0 up
sudo brctl addif virbr0 tap0

$ chmod 755 ./tap.sh

 

탭 인터페이스 생성 및 체크

tap.sh 스크립트를 동작시켜 tap 인터페이스를 생성한다.

$ ./tap.sh
add tap0 to virbr0 bridge
------------------------------------------------------
[sudo] password for jake:
Set 'tap0' nonpersistent
Set 'tap0' persistent and owned by uid 1000

 

네트워크 동작 확인

다음 명령들을 통해 tap 인터페이스 생성 후 브리지에 잘 포함되었는지와 네트웍이 정상 동작하는 것을 확인한다.

  • 사용하는 리눅스 패키지 및 버전에 따라 enp0s3 대신 eth0가 나올 수도 있다.
$ ifconfig
enp0s3    Link encap:Ethernet  HWaddr 08:00:27:59:bc:f3  
          UP BROADCAST RUNNING PROMISC MULTICAST  MTU:1500  Metric:1
          ...
tap0      Link encap:Ethernet  HWaddr 02:e4:fd:72:d5:13  
          UP BROADCAST MULTICAST  MTU:1500  Metric:1
          ...
virbr0    Link encap:Ethernet  HWaddr 02:e4:fd:72:d5:13  
          inet addr:20.0.2.4  Bcast:20.0.2.255  Mask:255.255.255.0
          ...
$ brctl show
bridge name    bridge id        STP enabled    interfaces
virbr0        8000.02e4fd72d513    no          enp0s3
                                               tap0

$ ping hello.net
PING hello.net (52.216.18.242) 56(84) bytes of data.
64 bytes from 52.216.18.242: icmp_seq=1 ttl=33 time=239 ms
64 bytes from 52.216.18.242: icmp_seq=2 ttl=33 time=235 ms

$ route
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         20.0.2.2        0.0.0.0             UG    0      0        0 virbr0
20.0.2.0        *               255.255.255.0       U     0      0        0 virbr0

 

2. 게스트 OS용 커널과 루트 파일 시스템 준비

이제 QEMU에서 작동시킬 게스트 OS용 Linaro 커널과 루트 파일 시스템을 준비한다.

 

다음 그림과 같은 디렉토리 구성을 사용할 계획이다.

 

Linaro 커널 다운로드

유저 작업 디렉토리에서 다음과 같이 Linaro 스테이블 커널 v4.9 또는 v4.14에 대한 소스를 git 툴을 사용하여 다운로드 한다.

  • –depth 1을 사용하여 다운 받는 용량을 줄였다.
  • -b <브랜치 명> 플래그를 사용하여 해당 브랜치를 선택한다.
  • lsk-4.9 또는 lsk-4.14 디렉토리가 만들어진다.
  • 관련 사이트: Linaro Stable Kernel (LSK) | Linaro.org
$ git clone --depth 1 -b linux-linaro-lsk-v4.9 https://git.linaro.org/kernel/linux-linaro-stable.git/ lsk-4.9
  or
$ git clone --depth 1 -b linux-linaro-lsk-v4.14 https://git.linaro.org/kernel/linux-linaro-stable.git/ lsk-4.14

 

다음 사이트에서 적절한 루트 파일 시스템용 이미지 또는 압축 파일을 다운받는다. 패키지들은 여러 가지 형태인데 이 글에서는 openembedded와 debian 계열의 패키지를 선택하여 설명한다.

 

예)

 

Linaro release에서 제공하는 루트 파일 시스템들은 크게 두 가지로 형태로 나뉜다.

  • 1) 압축된 완성 이미지 디스크
    • 파티션이 1~2개로 구성된 이미지 디스크 형태로 루트 파일들이 포함되어 있고, 보통 압축 시 다음과 같은 이름 형태를 사용하여 제공한다.
      • *.img.gz,
      • *.img.xz
      • *.rootfs.ext4.gz
      • *.rootfs.ext4.xz
      • *.rootfs.tar.gz
      • *.rootfs.tar.xz
    • 아래 샘플 두 가지는 압축된 이미지 디스크 파일로 제공한다.
      • 15.07월: vexpress64-openembedded_lamp-armv8-gcc-4.9_20150725-725.img.gz
        • 특징: openembedded 패킹 + vexpress64 HW + 커널 v4.2 + gcc + lamp(apache2 + mysqld)
      • 17.02월: rpb-console-image-lava-juno-20170223094505-36.rootfs.ext4.gz
        • 특징: linaro lava 패킹 + juno HW + 커널 v4.9.39 + gcc
  • 2) 압축된 루트 파일들
    • 루트 파일 시스템을 만들기 위한 압축 파일들만이 제공된다.
      • *.tar.gz
      • *.tar.xz
    • 아래 샘플은 루트 파일들을 압축하여 제공하므로 번거롭더라도 실제로 사용하기 전에 파티션을 가진 이미지 디스크를 만들고, 그 안에 복사하여 준비한다.
      • 18.04월: linaro-stretch-developer-20180416-89.tar.gz
        • 특징: debian 패킹 + gcc v6.3

 

Linaro Release에서 사용하는 단어 예를 설명한다.

  • console & minimal
    • gcc 및 기본 툴만 탑재
  • desktop
    • desktop에 준하는 더 많은 툴을 탑재
  • lamp
    • gcc + apache2 + mysql 데몬 탑재 (웹 서비스 스택)
  • lava
    • 리눅스 오토메이션 테스트 용
  • stretch
    • 데비안 리눅스의 배포판 코드명
    • kernel v4.9 LTS 기반으로 만들었다.

 

1) 압축된 완성 이미지 디스크로 준비하는 과정

유저 작업 디렉토리에서 다시 qq2 디렉토리로 이동 후 루트 파일 시스템이 포함된 이미지를 다운로드하고, 적절한 압축 해제 유틸리티를 사용하여 압축을 해제한다.

  • 주의: gzip에서 -k 옵션을 사용하지 않으면 압축이 풀린 후 기존 압축된 파일은 자동으로 삭제된다.
$ cd qq2
$ wget https://releases.linaro.org/openembedded/aarch64/15.07/vexpress64-openembedded_lamp-armv8-gcc-4.9_20150725-725.img.gz
$ gzip -d vexpress64-openembedded_lamp-armv8-gcc-4.9_20150725-725.img.gz

 

이미지 정보 확인

이미지 정보에서 Start에 해당하는 숫자들이 mount할 때 필요한 정보이다.

  • 보통 1~5개의 파티션으로 나뉘어 있다.
$ fdisk -l vexpress64-openembedded_lamp-armv8-gcc-4.9_20150725-725.img

Disk vexpress64-openembedded_lamp-armv8-gcc-4.9_20150725-725.img : 3221 MB, 3221225472 bytes
255 heads, 63 sectors/track, 391 cylinders, total 6291456 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0xdf9ff8a9
                                                            Device Boot      Start         End      Blocks   Id  System
vexpress64-openembedded_lamp-armv8-gcc-4.9_20150725-725.img1   *                63      155646       77792    e  W95 FAT16 (LBA)         <- (offset=63 * 512 = 32256 )
vexpress64-openembedded_lamp-armv8-gcc-4.9_20150725-725.img2                155648     6291455     3067904   83  Linux                   <- (offset=155648 * 512 = 79691776 )

 

1개의 파티션으로 되어있는 경우는 추후 mount할 때 offset 지정을 할 필요 없다.

fdisk -l rpb-console-image-lava-dragonboard-410c-20170803175648-18.rootfs.ext4
Disk rpb-console-image-lava-dragonboard-410c-20170803175648-18.rootfs.ext4: 1.5 GiB, 1556086784 bytes, 3039232 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes

 

이미지 마운트

qq2 디렉토리 위치에서 이미지를 마운트한다.

  • 주의: 아래 스크립트의 offset을 지정할 때 위에서 확인한 Start 값 * 512를 계산하여 사용해야 한다.
$ mkdir mnt1
$ mkdir mnt2

$ sudo mount -v -o offset=32256    -t vfat vexpress64-openembedded_lamp-armv8-gcc-4.9_20150725-725.img mnt1
$ sudo mount -v -o offset=79691776 -t ext4 vexpress64-openembedded_lamp-armv8-gcc-4.9_20150725-725.img mnt2
$ ls mnt2 
bin boot dev EFI etc home lib lost+found media mnt opt proc run sbin sys tmp usr var
$ cd ..
$ sudo umount mnt1
$ sudo umount mnt2

 

만일 1개의 파티션만을 사용하는 이미지인 경우 다음과 같이 사용한다.

$ mkdir mnt1
$ sudo mount -v -o loop rpb-console-image-lava-dragonboard-410c-20170803175648-18.rootfs.ext4 mnt1
$ ls mnt2 
bin boot dev etc home lib lost+found media mnt opt proc run sbin sys tmp usr var 
$ cd ..
$ sudo umount mnt2

 

2) 압축된 루트 파일로 준비하는 과정

만일 다운로드한 루트 파일 시스템이 파티션을 가진 이미지가 아니라서 마운트가 안되는 경우가 있다. 그런 경우는 루트파일 시스템을 그냥 압축만 해 놓은 상태이다. 이러한 파일은 1개의 파티션을 만들고 그 안에 압축된 디렉토리와 파일들을 풀어 넣어야 한다.

 

1개의 파티션 이미지 생성

1M * 4000개 = 약 4G의 용량을 가진 1개의 파티션을 가진 이미지를 만든다.

$ dd if=/dev/zero of=rootfs.ext4 bs=1M count=4000
$ mkfs.ext4 -F rootfs.ext4

 

마운트 및 루트 파일 시스템 구성

생성한 파티션 이미지를 마운트한 후 루트 파일을 풀어 이미지를 완성한다.

$ sudo mount rootfs.ext4 mnt1 -o loop
$ cd mnt1
$ sudo rm -rf lost+found
$ sudo tar xf ../linaro-stretch-developer-20180416-89.tar.gz 
$ ls
binary
$ sudo mv binary/* .
$ sudo rm binary -rf
$ cd ..
$ sudo umount mnt1

 

3. 게스트 OS(Linaro 커널) 빌드

커널을 빌드하는데 툴체인 및 관련 툴들이 사전에 설치되어 있어야 한다.

  • sudo apt-get install 명령을 사용하여 갖가지 툴들의 설치가 필요하다. (생략)

 

커널 빌드 환경 변수 준비

다음 항목들을 ~/.bashrc 파일 등에 기록해두자. 주의: 리나로 툴체인이 아래 PATH 지정한 디렉토리 위치에 설치되어 있어야 한다.

  • export PATH=/opt/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/bin:$PATH
  • export ARCH=arm64
  • export CROSS_COMPILE=aarch64-linux-gnu-

 

툴체인 확인

export PATH가 적용된 후에는 아래 명령을 입력 후 탭(tab) 키를 누르면 관련 파일들이 출력되는 것을 확인할 수 있다.

$ aarch64-linux-gnu-
aarch64-linux-gnu-addr2line   aarch64-linux-gnu-gcov-tool
aarch64-linux-gnu-ar          aarch64-linux-gnu-gdb
aarch64-linux-gnu-as          aarch64-linux-gnu-gfortran
aarch64-linux-gnu-c++         aarch64-linux-gnu-gprof
aarch64-linux-gnu-c++filt     aarch64-linux-gnu-ld
aarch64-linux-gnu-cpp         aarch64-linux-gnu-ld.bfd
aarch64-linux-gnu-elfedit     aarch64-linux-gnu-nm
aarch64-linux-gnu-g++         aarch64-linux-gnu-objcopy
aarch64-linux-gnu-gcc         aarch64-linux-gnu-objdump
aarch64-linux-gnu-gcc-5.3.1   aarch64-linux-gnu-ranlib
aarch64-linux-gnu-gcc-ar      aarch64-linux-gnu-readelf
aarch64-linux-gnu-gcc-nm      aarch64-linux-gnu-size
aarch64-linux-gnu-gcc-ranlib  aarch64-linux-gnu-strings
aarch64-linux-gnu-gcov        aarch64-linux-gnu-strip

 

툴체인 버전 확인

설치된 툴체인의 PATH가 잘 지정되었는지 확인해본다.

$ aarch64-linux-gnu-gcc --version
aarch64-linux-gnu-gcc (Linaro GCC 5.3-2016.02) 5.3.1 20160113
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 

빌드

다운 받은 게스트 OS용 커널이 있는 디렉토리에서 커널을 빌드해본다. 처음 빌드(make all) 시 PC 성능에 따라 수분~ 수십분이 소요된다.

  • lsk_defconfig를 사용하여 커널 디렉토리에 .config를 생성한다.
  • 처음 커널을 빌드하는 경우다음과 같은 유틸리티들이 먼저 설치되어 있어야 한다.
    • $ sudo apt-get install bison build-essential curl flex git pkg-config zlib1g-dev libglib2.0-dev zlib1g-dev libpixman-1-dev
$ cd lsk-4.9
$ make lsk_defconfig
$ make menuconfig
$ make -j 8

 

Guest OS에서 커널과 관련하여 개발이 필요한 경우  include 헤더들이 필요하다.

$ make -j 8 deb-pkg

 

4. QEMU에서 게스트 OS 실행 준비

QEMU를 사용하여 게스트 OS를 실행하려면 관련된 커멘드 옵션들이 상당히 다양하고 길다. 따라서 쉽게 가동하기 위해 스크립트를 만들어 사용하기로 한다.

 

게스트 OS 가동 스크립트 준비

qq2 디렉토리에서 다음 run.sh 스크립트를 준비하여 게스트 OS를 편하게 실행할 수 있도록 한다.

 

버추얼 머신(-M virt) 환경에서는 virtio-net-device 밖에 사용할 수 없다. 그러나 다른 머신 모드를 사용하면 다른 이더넷 드라이버를 에뮬레이션 할 수 있다. 예를 들어 인텔 이더넷 드라이버를 사용하려면 네트웍 부분을 다음과 같이 변경할 수 있다. (다음 두 줄에서 id를 다르게 설정해야 한다)

  • -net nic,id=mynet0,model=e1000 \
  • -net tap,id=mynet1,ifname=tap0,br=virbr0,script=no,downscript=no \

 

QEMU의 guest OS에서 사용할 네트워크 디바이스의 설정이 끝났으면 다음은 호스트와의 연동에 필요한 항목을 선택해야 한다. 외부 인터넷과 연동하려면 host의 tap 인터페이스와 연동이 필수이다. 그렇지 않고 내부에 host와의 tcp/udp 연동만 할 경우에는 user 모드 드라이버를 선택할 수 있다. 다만 user 모드 드라이버를 사용하는 경우 ping등이 지원되지 않는다.

  • -device virtio-net-device,netdev=mynet2 \
  • -netdev user,id=mynet2,net=20.0.2.0/24,dhcpstart=20.0.2.5 \

 

아래의 run.sh 스크립트를 준비한다.

  • 주의:
    • 다음 스크립트의 -dtb ${DTB_FILE} \ 행을 삭제하는 경우 virt 머신에 내장된(embed) 디폴트 디바이스 트리가 자동으로 적용된다.
    • 만일 1개의 파티션을 갖는 이미지를 사용하는 경우 root=/dev/vda로 변경하여 사용한다.
$ cd qq2
$ vi run.sh
WORK_DIR=${HOME}"/workspace"
KERNEL_DIR=${WORK_DIR}"/lsk-4.9"
KERNEL_IMG=${KERNEL_DIR}"/arch/arm64/boot/Image"
ROOTFS="vexpress64-openembedded_lamp-armv8-gcc-4.9_20150725-725.img"
DTB_FILE="virt.dtb"

if [ 1 == 0 ]; then
qemu-system-aarch64 -smp 2 -m 1024 -cpu cortex-a57 -nographic \
        -machine virt,dumpdtb=virt_original.dtb \
        -kernel ${KERNEL_IMG} \
        -append 'root=/dev/vda2 rw rootwait mem=1024M console=ttyAMA0,38400n8' \
        -device virtio-net-device,netdev=mynet1 \
        -netdev tap,id=mynet1,ifname=tap0,br=virbr0,script=no,downscript=no \
        -device virtio-blk-device,drive=disk \
        -drive if=none,id=disk,file=${ROOTFS},format=raw
else
qemu-system-aarch64 -smp 2 -m 1024 -cpu cortex-a57 -nographic \
        -machine virt \
        -kernel ${KERNEL_IMG} \
        -dtb ${DTB_FILE} \                   <- 디바이스 트리를 별도로 작성하지 않을 사람은 삭제
        -append 'root=/dev/vda2 rw rootwait mem=1024M console=ttyAMA0,38400n8' \
        -device virtio-net-device,netdev=mynet1 \
        -netdev tap,id=mynet1,ifname=tap0,br=virbr0,script=no,downscript=no \
        -device virtio-blk-device,drive=disk \
        -drive if=none,id=disk,file=${ROOTFS},format=raw
fi
reset
$ chmod 755 ./run.sh

 

게스트 OS 중단 스크립트 준비

실행된 게스트 OS의 실행을 강제로 종료시키기 위해 다음 fin.sh 스크립트를 준비한다.

$ vi fin.sh
ps -ef | grep 'qemu-system-aarch64' -m 1 | awk '{print $2}' | xargs kill -9

$ chmod 755 ./fin.sh

 

디바이스 트리 사용(option)

virt 머신(-M virt 옵션)을 사용하는 구성에서는 임베드된 디바이스 트리를 사용하는데 이를 외부에서 지정하는 방법을 알아보자.

 

run.sh 스크립트 내부의 if 조건을 1 == 1로 변경하여 실행시키는 경우 virt 머신 내부에 포함된 virt_original.dtb가 자동으로 생성된다.

  • 한 번 생성한 후에는 if 조건을 원래대로 돌려 놓는다.

 

$ cat virt.dts
/dts-v1/;

/ {
     interrupt-parent = <0x8001>;
     #size-cells = <0x2>;
     #address-cells = <0x2>;
     compatible = "linux,dummy-virt";

     platform@c000000 {
          interrupt-parent = <0x8001>;
          ranges = <0x0 0x0 0xc000000 0x2000000>;
          #address-cells = <0x1>;
          #size-cells = <0x1>;
          compatible = "qemu,platform", "simple-bus";
     };

     fw-cfg@9020000 {
          dma-coherent;
          reg = <0x0 0x9020000 0x0 0x18>;
          compatible = "qemu,fw-cfg-mmio";
     };

     virtio_mmio@a000000 {
          dma-coherent;
          interrupts = <0x0 0x10 0x1>;
          reg = <0x0 0xa000000 0x0 0x200>;
          compatible = "virtio,mmio";
     };

     (virtio_mmio 노드 반복 생략)

     gpio-keys {
          #address-cells = <0x1>;
          #size-cells = <0x0>;
          compatible = "gpio-keys";

          poweroff {
               gpios = <0x8003 0x3 0x0>;
               linux,code = <0x74>;
               label = "GPIO Key Poweroff";
          };
     };

     pl061@9030000 {
          phandle = <0x8003>;
          clock-names = "apb_pclk";
          clocks = <0x8000>;
          interrupts = <0x0 0x7 0x4>;
          gpio-controller;
          #gpio-cells = <0x2>;
          compatible = "arm,pl061", "arm,primecell";
          reg = <0x0 0x9030000 0x0 0x1000>;
     };

     pcie@10000000 {
          interrupt-map-mask = <0x1800 0x0 0x0 0x7>;
          interrupt-map = <0x0 0x0 0x0 0x1 0x8001 0x0 0x0 0x0 0x3 0x4 0x0 0x0 0x0 0x2 0x8001 0x0 0x0 0x0 0x4 0x4 0x0 0x0 0x0 0x3 0x8001 0x0 0x0 0x0 0x5 0x4 0x0 0x0 0x0 0x4 0x8001 0x0 0x0 0x0 0x6 0x4 0x800 0x0 0x0 0x1 0x8001 0x0 0x0 0x0 0x4 0x4 0x800 0x0 0x0 0x2 0x8001 0x0 0x0 0x0 0x5 0x4 0x800 0x0 0x0 0x3 0x8001 0x0 0x0 0x0 0x6 0x4 0x800 0x0 0x0 0x4 0x8001 0x0 0x0 0x0 0x3 0x4 0x1000 0x0 0x0 0x1 0x8001 0x0 0x0 0x0 0x5 0x4 0x1000 0x0 0x0 0x2 0x8001 0x0 0x0 0x0 0x6 0x4 0x1000 0x0 0x0 0x3 0x8001 0x0 0x0 0x0 0x3 0x4 0x1000 0x0 0x0 0x4 0x8001 0x0 0x0 0x0 0x4 0x4 0x1800 0x0 0x0 0x1 0x8001 0x0 0x0 0x0 0x6 0x4 0x1800 0x0 0x0 0x2 0x8001 0x0 0x0 0x0 0x3 0x4 0x1800 0x0 0x0 0x3 0x8001 0x0 0x0 0x0 0x4 0x4 0x1800 0x0 0x0 0x4 0x8001 0x0 0x0 0x0 0x5 0x4>;
          #interrupt-cells = <0x1>;
          ranges = <0x1000000 0x0 0x0 0x0 0x3eff0000 0x0 0x10000 0x2000000 0x0 0x10000000 0x0 0x10000000 0x0 0x2eff0000 0x3000000 0x80 0x0 0x80 0x0 0x80 0x0>;
          reg = <0x0 0x3f000000 0x0 0x1000000>;
          msi-parent = <0x8002>;
          dma-coherent;
          bus-range = <0x0 0xf>;
          #size-cells = <0x2>;
          #address-cells = <0x3>;
          device_type = "pci";
          compatible = "pci-host-ecam-generic";
     };

     pl031@9010000 {
          clock-names = "apb_pclk";
          clocks = <0x8000>;
          interrupts = <0x0 0x2 0x4>;
          reg = <0x0 0x9010000 0x0 0x1000>;
          compatible = "arm,pl031", "arm,primecell";
     };

     pl011@9000000 {
          clock-names = "uartclk", "apb_pclk";
          clocks = <0x8000 0x8000>;
          interrupts = <0x0 0x1 0x4>;
          reg = <0x0 0x9000000 0x0 0x1000>;
          compatible = "arm,pl011", "arm,primecell";
     };

     pmu {
          interrupts = <0x1 0x7 0x304>;
          compatible = "arm,armv8-pmuv3";
     };

     intc {
          phandle = <0x8001>;
          reg = <0x0 0x8000000 0x0 0x10000 0x0 0x8010000 0x0 0x10000>;
          compatible = "arm,cortex-a15-gic";
          ranges;
          #size-cells = <0x2>;
          #address-cells = <0x2>;
          interrupt-controller;
          #interrupt-cells = <0x3>;

          v2m {
               phandle = <0x8002>;
               reg = <0x0 0x8020000 0x0 0x1000>;
               msi-controller;
               compatible = "arm,gic-v2m-frame";
          };
     };

     flash@0 {
          bank-width = <0x4>;
          reg = <0x0 0x0 0x0 0x4000000 0x0 0x4000000 0x0 0x4000000>;
          compatible = "cfi-flash";
     };

     psci {
          migrate = <0xc4000005>;
          cpu_on = <0xc4000003>;
          cpu_off = <0x84000002>;
          cpu_suspend = <0xc4000001>;
          method = "hvc";
          compatible = "arm,psci-0.2", "arm,psci";
     };

     cpus {
          #size-cells = <0x0>;
          #address-cells = <0x1>;

          cpu@0 {
               reg = <0x0>;
               enable-method = "psci";
               compatible = "arm,cortex-a57";
               device_type = "cpu";
          };

          cpu@1 {
               reg = <0x1>;
               enable-method = "psci";
               compatible = "arm,cortex-a57";
               device_type = "cpu";
          };
     };

     timer {
          interrupts = <0x1 0xd 0x304 0x1 0xe 0x304 0x1 0xb 0x304 0x1 0xa 0x304>;
          always-on;
          compatible = "arm,armv8-timer", "arm,armv7-timer";
     };

     apb-pclk {
          phandle = <0x8000>;
          clock-output-names = "clk24mhz";
          clock-frequency = <0x16e3600>;
          #clock-cells = <0x0>;
          compatible = "fixed-clock";
     };

     memory {
          reg = <0x0 0x40000000 0x0 0x40000000>;
          device_type = "memory";
     };

     chosen {
          bootargs = "root=/dev/vda2 rw rootwait mem=1024M console=ttyAMA0,38400n8";
          stdout-path = "/pl011@9000000";
     };
};

 

디바이스 트리에 Custom 노드 추가(Option)

먼저 생성된 virt_default.dtb를 아래의 명령으로 dts 포맷으로 변경한다.

  • $ dtc -I dtb -O dts virt_default.dtb -o virt_default.dts

 

virt_default.dts 파일이 생성되었으면 이를 virt.dts로 복사하고 스크립트의 마지막에 Custom 노드를 추가한다.

  • $ cp virt_default.dts virt.dts

 

다음은 virt.dts에 gpio 노드를 추가한 모습을 보여준다.

$ vi virt.dts

    (생략)

    gpio {
        compatible = "foo,foo-gpio";
        reg = <0x0 0x0 0x0 0x4>;
        ngpios = <2>;
        #gpio-cells = <2>;
        gpio-controllers;
        interrupt-controller;
        interrupts = <0 33 0>;
    };
}

 

마지막으로 다음 명령을 사용하여 virt.dts를 virt.dtb로 변환한다.

$ dtc -I dts -O dtb virt.dts -o virt.dtb
$ ls virt* -la
-rw-rw-r-- 1 jake jake 65536 5월 9 15:55 virt_default.dtb
-rw-rw-r-- 1 jake jake 8523  5월 9 16:12 virt_default.dts
-rw-rw-r-- 1 jake jake 7617  5월 9 16:06 virt.dtb
-rw-rw-r-- 1 jake jake 8701  5월 9 16:06 virt.dts

 

5. QEMU로 게스트 OS(Linaro 커널) 실행

 

$ ./run.sh
normal option.
[    0.000000] Booting Linux on physical CPU 0x0
[    0.000000] Linux version 4.9.94-gd1480f9-dirty (jake@jake-vb) (gcc version 5.3.1 20160113 (Linaro GCC 5.3-2016.02) ) #7 SMP PREEMPT Wed May 9 13:58:03 KST 2018
[    0.000000] Boot CPU: AArch64 Processor [411fd070]
[    0.000000] Memory limited to 1024MB
...

Last login: Wed May  9 05:21:04 UTC 2018 on tty1
root@genericarmv8:~#

 

문제점 해결

아래 WARNING 로그에 다음과 같은 메시지들 중 하나라도 나타나면 네트워크가 제대로 동작하지 않을 것이다.

  • “Warning: netdev mynet0 has no peer”
  • “Warning: vlan 0 is not connected to host network”
  • “Warning: vlan 0 with no nics”

 

또는 위의 메시지 출력도 없고 콘솔 출력이 없는 경우 다음 두 가지가 잘못되었을 가능성이 있다.

  • 커널 크로스 컴파일이 잘못된 경우
  • QEMU의 스탠다드 콘솔 출력 문제

 

커널 크로스 컴파일이 잘못된 경우

커널이 위치한 디렉토리에서 아래와 같이 커널이 크로스 컴파일되었는지 확인한다.

$ file vmlinux
vmlinux: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked, BuildID[sha1]=d85b613e8a8b495e70e79814917c86a88afecd8e, not stripped

 

QEMU의 스탠다드 콘솔 출력 문제

QEMU가 자신의 환경 설정과 동일하게 설정되지 않은 경우 이므로 QEMU 소스를 받아 빌드하여 사용한다. 이렇게 소스를 직접 빌드하는 경우 configure 유틸리티가 자신의 호스트에 설치된 라이브러리를 분석하여 적합하게 설정한다.

$ git clone git://git.qemu.org/qemu.git qemu
$ cd qemu
$ sudo apt-get install libsdl-dev-image1.2-dev          <- 안되면 libsdl1.2-dev (or libsdl2-dev)
$ git submodule update --init dtc 
$ git submodule update --init pixman                    <- 또는 (sudo apt-get install libpixman-1-dev)
$ ./configure --target-list=aarch64-softmmu --enable-fdt --enable-vhost-net
$ make
$ sudo make install

 

잘 동작하는 경우 커널 버전 확인

커널 버전 4.9 또는 4.14가 잘 설치되었음을 알 수 있다.

root@genericarmv8:~# uname -r
4.9.94-gd1480f9

 

mysqld와 apache2 데몬 서비스 중단 (lamp 패키지 사용 시)

lamp 패키지가 추가되어 있는 이미지에서는 불필요한 데몬 두 개와 관련된 시작 링크들을 삭제한다.

  • 구동 절차가 SysVinit을 사용하는 경우이다. (systemd는 다르다. 추후 확인 필요)
$ sudo update-rc.d -f mysqld remove
update-rc.d: /etc/init.d/mysqld exists during rc.d purge (continuing)
Removing any system startup links for mysqld ...
  /etc/rc0.d/K45mysqld
  /etc/rc1.d/K45mysqld
  /etc/rc5.d/S45mysqld
  /etc/rc6.d/K45mysqld

$ sudo update-rc.d -f apache2 remove
update-rc.d: /etc/init.d/apache2 exists during rc.d purge (continuing)
Removing any system startup links for apache2 ...
  /etc/rc0.d/K20apache2
  /etc/rc1.d/K20apache2
  /etc/rc2.d/S91apache2
  /etc/rc3.d/S91apache2
  /etc/rc4.d/S91apache2
  /etc/rc5.d/S91apache2
  /etc/rc6.d/K20apache2

 

6. 게스트 OS 네트워크 설정

부트 파일 시스템의 구동 방식이 전통적인 방식의 SysVinit 또는 최근 추세인 systemd 둘 중 어느 방법을 사용하는지에 따라 설정방법이 다르다. 또한 Lan Manager 및 dsnresolv의 사용 유무도 네트 워크 설정 방법을 다르게 하는 요인이다. 이 글에서는 위의 예제에서 사용한 2 가지의 루트 파일 시스템 이미지에 대한 설정 방법을 가이드한다.

 

vexpress64-openembedded_lamp-armv8-gcc-4.9_20150725-725.img.gz 사용 시

SysVinit을 사용한 전통적인 방법으로 루트 파일 시스템으로 구성되어 있다. (Lan Manager, resolvconf 탑재되지 않음)

  • 최신 desktop 등에서는 systemd가 사용되지만 embedded 시스템에서는 여전히 SysVinit이 많이 이용되고 있다.

 

다음 파일을 수정해서 사용할 ip 및 gateway를 지정한다.

$ vi /etc/network/interfaces
auto eth0
iface eth0 inet static
	address 20.0.2.5
	netmask 255.255.255.0
	gateway 20.0.2.4

 

 

resolvconf가 탑재되지 않은 루트 파일 시스템에서의 dns name 서버 등록은 resolv.conf 파일을 수정해야 하는데 다음과 같이 이 파일이 휘발성 메모리를 사용하므로 이를 부트 후에 런타임에서 수정해야 함을 알 수 있다.

$ ls resolv.conf -la
lrwxrwxrwx 1 root root 20 May  9 02:08 resolv.conf -> /var/run/resolv.conf

 

따라서 아래와 같이 디폴트 부트 시퀀스 5레벨에 해당하는 위치에서 동작하는 스크립트를 작성한다.

$ vi /etc/init.d/route_init.sh
echo route init...
echo "nameserver 168.126.63.1" > /etc/resolv.conf

$ chmod 755 /etc/init.d/route_init.sh

$ cd /etc/rc5.d
$ ln -s ../init.d/route_init.sh S02routeinit.sh

 

linaro-stretch-developer-20180416-89.tar.gz 사용 시

최신 Trend인 systemd가 사용되었고 Network Manager, resolvconf등도 모두 탑재된 루트 파일 시스템으로 구성되어 있다.

 

다음과 같이 Guest OS에서는 무선 네트웍을 사용하지 않으니 Network Manager가 이더넷을 관리하지 못하게 managed=false인 상태로 그냥 수정없이 사용한다.

$ cat /etc/NetworkManager/NetworkManager.conf 
[main]
plugins=ifupdown,keyfile

[ifupdown]
managed=false

 

다음 파일을 수정해서 사용할 ip 및 gateway를 지정한다. (네트웍 디바이스에 따라 eth0 대신 enp0s1일 수도 있다.)

$ vi /etc/network/interfaces
auto eth0
iface eth0 inet static
	address 20.0.2.5
	netmask 255.255.255.0
	gateway 20.0.2.4

 

resolvconf가 탑재되어 알아서 상위 네트웍에서 dns 네임 서버를 찾아 다음과 같이 등록하므로 특별히 추가 설정을 할 필요 없다.

$ cat /etc/resolv.conf 
# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)
#     DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN
nameserver 8.8.8.8

 

위의 내용에 nameserver 127.0.0.53이 등록되어 있는 경우 불필요하여 삭제하려면 다음과 같은 명령을 사용한다.

$ systemctl disable systemd-resolved

 

최종  동작 확인

$ reboot
...
Last login: Thu May 10 14:50:58 UTC 2018 on tty1

root@genericarmv8:~#

 

gcc 컴파일러 동작 확인
$ gcc --version
gcc (Linaro GCC 4.9-2015.06) 4.9.4 20150629 (prerelease)
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 

인터넷 동작 확인
root@genericarmv8:~# cat /etc/resolv.conf 
nameserver 168.126.63.1

root@genericarmv8:~# ifconfig
eth0      Link encap:Ethernet  HWaddr 52:54:00:12:34:56  
          inet addr:20.0.2.5  Bcast:20.0.2.255  Mask:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          ...
root@genericarmv8:~# route
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         jake-vb.local   0.0.0.0         UG    0      0        0 eth0
20.0.2.0        *               255.255.255.0   U     0      0        0 eth0

root@genericarmv8:~ # ping hello.net
PING hello.net (52.216.20.122): 56 data bytes
64 bytes from 52.216.20.122: seq=0 ttl=36 time=199.754 ms
64 bytes from 52.216.20.122: seq=1 ttl=36 time=197.717 ms

 

참고

 

 

 

GPIO Subsystem -3- (Device Tree)

문영일 2 Comments

 

gpio 데이터를 매핑하여 사용할 수 있는 방법은 다음과 같이 약 3가지 방법이 있다.

  • 디바이스 트리로 정의 (가장 최근 Trend)
    • ACPI 마저도 등록하여 사용할 수 있다.
  • Legacy Board/Machine specific code에서 플랫폼 데이터로 정의
    • 사실 GPIO 매핑을 플랫폼 데이터에 등록하여 사용하는 경우는 많지 않았다. 그냥 핀 번호로 사용하는 경우가 대부분이었다.
  • ACPI 펌웨어 테이블에 정의

 

디바이스 트리를 사용하는 GPIO 매핑

GPIO Controller 노드

디바이스 노드 내부에 “gpio-controller” 속성이 있으면 GPIO Controller 노드를 의미한다.

 

cell 개수

#gpio-cells = <2> 속성은 two-cell 데이터 argument를 사용함을 의미한다.

  • gpio1 controller는 2개의 cell을 사용하여 디바이스 드라이버가 2개의 argument를 받아 처리한다.
  • gpio2 controller는 1개의 cell을 사용하여 디바이스 드라이버가 1개의 argument를 받아 처리한다.
  • 지정되지 않는 경우 2 cell 방식을 사용한다.
	gpio1: gpio1 {
		gpio-controller;
		 #gpio-cells = <2>;
	};
	gpio2: gpio2 {
		gpio-controller;
		 #gpio-cells = <1>;
	};
	[...]

	enable-gpios = <&gpio2 2>;
	data-gpios = <&gpio1 12 0>,
		     <&gpio1 13 0>,
		     <&gpio1 14 0>,
		     <&gpio1 15 0>;

 

Pin control subsystem과의 연동

pin control 서브시스템과의 연동은 gpio controller 노드에서 “gpio-ranges” 속성을 사용하여 한다. 다음 코드를 알아보자.

“gpio-ranges” 속성이 가리키는 phandle은 연계된 pin controller 노드를 가리켜야 한다. 그리고 1~3개의 인자를 사용할 수 있으며, 배열 사용을 지원한다.

  • 1~2개 인자를 사용하는 경우 반드시 “gpio-ranges-group-names” 속성을 사용하여야 한다.
    • 첫 번째 인자: 시작 gpio 번호(offset)
    • 두 번째 인자: “gpio-ranges-group-names” 속성에서 지정한 그룹명에 해당하는 pin 시작 번호와 개수를 사용한다. 따라서 이 항목이 사용되는 경우에는 반드시 0이어야 한다.
	gpio-ranges = <&pinctrl 0 0>; 
        gpio-ranges-group-names = "gpioa"

 

  • 3개 인자를 사용하는 경우 “gpio-ranges-group-names” 속성이 필요 없고, 사용되더라도 빈 문자열이어야 한다.
    • 첫 번째 인자: 시작 gpio 번호(offset)
    • 두 번째 인자: 시작 pin 번호(offset)
    • 세 번째 인자: gpio 개수
	gpio-ranges = <&pinctrl 0 0 16>;

 

다음은 배열 형태로 사용된 경우이다.

        gpio-ranges = <&pinctrl 0 16 3>, <&pinctrl 14 30 2>;

 

다음 사용 사례를 살펴본다.

  • iomux pin controller 노드
    • pctl-gpio-a 노드는 pinmux 노드 2개를 선언하였다.
    • 이 벤더의 디바이스 트리 노드 맵 변환은 고유의 방법을 사용하는데 pins 속성이나 groups 속성이 지정되지 않았음을 알 수 있다. 이러한 경우 consumer 디바이스 측에서 사용하는 compact 노드명을 그대로 그룹명으로 사용한다. 아래 두 consumer 디바이스의 노드명을 보면 “uart@FF100000″과 “gpio@FF140000″이 있는데 compact 노드명을 그룹명으로 사용하므로 이들은 각각 “uart”와 “gpio” 그룹명이 된다.
  • uart (pin control consumer) 노드
    • “default” 스테이트를 사용하여 pinctrl-0 속성에서 지정된 phandle 노드로 pinmux/pinconf 매핑을 등록한다. “uart” 그룹과 pinmux 노드에서 정의한 “uart0” 펑션을 매핑한다.
    • 관련 함수: drivers/pinctrl/pinctrl-tb10x.c – tb10x_dt_node_to_map()
  • gpioa (pin control consumer) 노드
    • “gpio-ranges” 속성을 사용하여 iomux 핀 controller 노드와 연계한다.
    • gpio 0번부터 pin controller에서 구현된 그룹명들 중 “gpio-ranges-group-names” 속성에서 지정한 “gpioa” 그룹명에 해당하는 핀들을 gpio 핀들로 등록하게 한다.
iomux: iomux@FF10601c {
        compatible = "abilis,tb10x-iomux";
        reg = <0xFF10601c 0x4>;
        pctl_gpio_a: pctl-gpio-a {
                abilis,function = "gpioa";
        };
        pctl_uart0: pctl-uart0 {
                abilis,function = "uart0";
        };
};
uart@FF100000 {
        compatible = "snps,dw-apb-uart";
        reg = <0xFF100000 0x100>;
        clock-frequency = <166666666>;
        interrupts = <25 1>;
        reg-shift = <2>;
        reg-io-width = <4>;
        pinctrl-names = "default";
        pinctrl-0 = <&pctl_uart0>;
};
gpioa: gpio@FF140000 {
        compatible = "abilis,tb10x-gpio";
        reg = <0xFF140000 0x1000>;
        gpio-controller;
        #gpio-cells = <2>;
        ngpios = <3>;
        gpio-ranges = <&iomux 0 0>;
        gpio-ranges-group-names = "gpioa";
};

 

line 명 지정

gpio controller를 등록하기 전에 gpio_chip->ngpios에 gpio 개수를 등록하거나 “ngpios” 속성을 사용하여 gpio 핀 개수를 지정하여 gpio controller가 사용하는 gpio 핀 개수를 먼저 알고 있어야한다. 그 후 “gpio-line-names” 속성을 사용하여 gpio 핀 개수만큼 gpio 디스크립터들의 이름을 지정한다.

  • gpio 디스크립터들의 핀명이 gpio 디바이스  드라이버의 내부 코드로 이미 정해져있는 경우에는 별도로 “gpio-line-names” 속성을 사용할 필요 없다.
gpio-controller@00000000 {
	compatible = "foo";
	reg = <0x00000000 0x1000>;
	gpio-controller;
	#gpio-cells = <2>;
	ngpios = <18>;
	gpio-line-names = "MMC-CD", "MMC-WP", "VDD eth", "RST eth", "LED R",
		"LED G", "LED B", "Col A", "Col B", "Col C", "Col D",
		"Row A", "Row B", "Row C", "Row D", "NMI button",
		"poweroff", "reset";
}

 

hog 처리

gpio 컨트롤러의 하위 노드들에서 “gpio-hog” 속성이 발견되는 경우 지정된 gpio 핀 상태를 즉시 설정한다. 커널 v.4.1-rc1에 추가되었다.

  • “gpios” 속성에 해당하는 argument의 처리는 벤더가 제공하는 gpio 컨트롤러에서 구현되는데, 대부분의 벤더들은 이의 구현을 하지 않고 gpio simple 변환을 사용한다.
    • 2개의 셀을 사용하는 gpio simple 변환은 gpio 시작 번호(offset)를 변환없이 그대로 사용하고, gpio 설정 값에 해당하는 두 번째 인수 역시 그대로 변환 없이 사용한다.
  • 참고: gpio: add GPIO hogging mechanism
	qe_pio_a: gpio-controller@1400 {
		compatible = "fsl,qe-pario-bank-a", "fsl,qe-pario-bank";
		reg = <0x1400 0x18>;
		gpio-controller;
		#gpio-cells = <2>;

		line_b {
			gpio-hog;
			gpios = <6 0>;
			output-low;
			line-name = "foo-bar-gpio";
		};
	};

 

GPIO Client 노드 (for Consumer)

다음과 같이 “X-gpios = <&gpio_controller Y Z>;” 속성 형식을 사용하는 X 이름을 갖는 gpio 매핑은 Y와 Z 두 개의 셀을 데이터 argument를 사용하는데, 첫 번째 argument는 보통 gpio 번호, 두 번째는 상태를 지정한다.

  • led라는 이름으로 0~2번 인덱스 각각에 15~17번 핀을 active_high 상태로 동작하도록 매핑한다.
  • power라는 이름으로 1번 핀을 active_low 상태로 동작하도록 매핑한다.
    • GPIO_ACTIVE_LOW 상태에 대해서는 착각하기 쉬우므로 주의해야 한다.
	foo_device {
		compatible = "acme,foo";
		...
		led-gpios = <&gpio 15 GPIO_ACTIVE_HIGH>, /* red */
			    <&gpio 16 GPIO_ACTIVE_HIGH>, /* green */
			    <&gpio 17 GPIO_ACTIVE_HIGH>; /* blue */

		power-gpios = <&gpio 1 GPIO_ACTIVE_LOW>;
	};

 

코드에서 위의 매핑을 불러서 동작 시키고자할 때에는 다음과 같이 호출한다.

  • led 라는 이름의 gpio 0~2번 인덱스의 로지컬 출력을 high로 설정한다.
    • 매핑 시 active_high에서 동작하게 하였으므로 로지컬 출력을 high로 하면 gpio 핀은 물리적 high 상태가 된다. 의미적으로는 led가 점등(on)한다.
  • power라는 이름의 gpio 로지컬 출력을 high로 설정한다.
    • 매핑 시 active_low에서 동작하게 하였으므로 로지컬 출력을 high로 하면 gpio 핀은 물리적 low 상태가 된다. 의미적으로는 파워가 켜진다.(on)
	struct gpio_desc *red, *green, *blue, *power;

	red = gpiod_get_index(dev, "led", 0, GPIOD_OUT_HIGH);
	green = gpiod_get_index(dev, "led", 1, GPIOD_OUT_HIGH);
	blue = gpiod_get_index(dev, "led", 2, GPIOD_OUT_HIGH);

	power = gpiod_get(dev, "power", GPIOD_OUT_HIGH);

 

참고

 

 

ACPI 펌웨어를 사용하는 GPIO 매핑

디바이스 트리를 사용하는 방법과 아주 유사한 방법으로 아래의 ACPI 디스크립션을 사용하는 방법이 있다. ACPI 5.1에서 소개된 _DSD (Device Specific Data)를 참조하기 바란다.

	Device (FOO) {
		Name (_CRS, ResourceTemplate () {
			GpioIo (Exclusive, ..., IoRestrictionOutputOnly,
				"\\_SB.GPI0") {15} // red
			GpioIo (Exclusive, ..., IoRestrictionOutputOnly,
				"\\_SB.GPI0") {16} // green
			GpioIo (Exclusive, ..., IoRestrictionOutputOnly,
				"\\_SB.GPI0") {17} // blue
			GpioIo (Exclusive, ..., IoRestrictionOutputOnly,
				"\\_SB.GPI0") {1} // power
		})

		Name (_DSD, Package () {
			ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
			Package () {
				Package () {
					"led-gpios",
					Package () {
						^FOO, 0, 0, 1,
						^FOO, 1, 0, 1,
						^FOO, 2, 0, 1,
					}
				},
				Package () {
					"power-gpios",
					Package () {^FOO, 3, 0, 0},
				},
			}
		})
	}

 

Platform 데이터에 GPIO 매핑 (deprecated)

일부 시스템에서 다음 매크로 함수 및 API를 사용하여 매핑을 플랫폼 데이터에 저장(bound)한 후 이를 lookup하여 사용하였었는데 지금은 사용하지 않는 방법이다.

	GPIO_LOOKUP(chip_label, chip_hwnum, con_id, flags)
	GPIO_LOOKUP_IDX(chip_label, chip_hwnum, con_id, idx, flags)

 

gpio 룩업 테이블 정의를 한 후

struct gpiod_lookup_table gpios_table = {
	.dev_id = "foo.0",
	.table = {
		GPIO_LOOKUP_IDX("gpio.0", 15, "led", 0, GPIO_ACTIVE_HIGH),
		GPIO_LOOKUP_IDX("gpio.0", 16, "led", 1, GPIO_ACTIVE_HIGH),
		GPIO_LOOKUP_IDX("gpio.0", 17, "led", 2, GPIO_ACTIVE_HIGH),
		GPIO_LOOKUP("gpio.0", 1, "power", GPIO_ACTIVE_LOW),
		{ },
	},
};

 

다음 함수로 등록을 한다.

gpiod_add_lookup_table(&gpios_table);

 

그런 후 아래와 같은 방식으로 호출하여 사용할 수 있다.

	struct gpio_desc *red, *green, *blue, *power;

	red = gpiod_get_index(dev, "led", 0, GPIOD_OUT_HIGH);
	green = gpiod_get_index(dev, "led", 1, GPIOD_OUT_HIGH);
	blue = gpiod_get_index(dev, "led", 2, GPIOD_OUT_HIGH);

	power = gpiod_get(dev, "power", GPIOD_OUT_HIGH);

 

디바이스 트리 소스

gpio controller 노드를 파싱하고 추가할 때의 함수 호출관계이다.

 

of_gpiochip_add()

drivers/gpio/gpiolib-of.c

int of_gpiochip_add(struct gpio_chip *chip)
{
        int status;

        if ((!chip->of_node) && (chip->parent))
                chip->of_node = chip->parent->of_node;

        if (!chip->of_node)
                return 0;

        if (!chip->of_xlate) {
                chip->of_gpio_n_cells = 2;
                chip->of_xlate = of_gpio_simple_xlate;
        }

        if (chip->of_gpio_n_cells > MAX_PHANDLE_ARGS)
                return -EINVAL;

        status = of_gpiochip_add_pin_range(chip);
        if (status)
                return status;

        /* If the chip defines names itself, these take precedence */
        if (!chip->names)
                devprop_gpiochip_set_names(chip);

        of_node_get(chip->of_node);

        return of_gpiochip_scan_gpios(chip);
}

gpio controller 오퍼레이션을 포함한 gpio_chip 구조체를 등록하고 디바이스 트리의 gpio controller 노드에서 각종 속성들을 파싱하여 처리한다.

  • 코드 라인 5~9 인자로 전달받은 gpio_chip 구조체에 디바이스 노드가 지정되지 않은 경우 부모 gpio controller 디바이스의 디바이스 노드를 알아와서 사용한다. 만일 디바이스 노드가 없는 경우 이 함수를 처리하지 않고 에러 없이 빠져나간다.
  • 코드 라인 11~13에서 gpio_chip의 (*of_xlate) 후크 함수가 구현되지 않은 경우 two cell 방식의 기본 함수인 og_gpio_simple_xlate()를 사용한다.
  • 코드 라인 16~17에서 gpio cell 수가 MAX_PHANDLE_ARGS(16)을 초과하는 경우 에러 결과를 반환한다.
  • 코드 라인 19~21에서 pin controller 노드와 연결되어 사용되는 gpio controller인 경우 “gpio-ranges” 속성을 사용하여 연계할 pin controller의 지정된 핀들을 gpio 컨트롤러에 등록한다.
  • 코드 라인 24~25에서 gpio controller 노드에서 gpio 이름이 주어지지 않은 경우 부모 gpio controller 노드의 “gpio-line-names” 속성 값들을 읽어서 gpio 디스크립터들의 name으로 사용한다.
    • gpio  controller 노드에서 “X-gpios ” 속성을 사용하지 않은 경우 “gpio-line-names” 속성에서 사용한 이름들을 gpio 이름으로 가져온다.
  • 코드 라인 29에서 gpio controller 노드의 서브 노드에서 “gpio-hog” 속성을 발견하는 경우 hog 매핑들을 읽어온다.

 

of_gpiochip_add_pin_range()

drivers/gpio/gpiolib-of.c

#ifdef CONFIG_PINCTRL
static int of_gpiochip_add_pin_range(struct gpio_chip *chip)
{
        struct device_node *np = chip->of_node;
        struct of_phandle_args pinspec;
        struct pinctrl_dev *pctldev;
        int index = 0, ret;
        const char *name;
        static const char group_names_propname[] = "gpio-ranges-group-names";
        struct property *group_names;

        if (!np)
                return 0;

        group_names = of_find_property(np, group_names_propname, NULL);

        for (;; index++) {
                ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3,
                                index, &pinspec);
                if (ret)
                        break;

                pctldev = of_pinctrl_get(pinspec.np);
                of_node_put(pinspec.np);
                if (!pctldev)
                        return -EPROBE_DEFER;

                if (pinspec.args[2]) {
                        if (group_names) {
                                of_property_read_string_index(np,
                                                group_names_propname,
                                                index, &name);
                                if (strlen(name)) {
                                        pr_err("%pOF: Group name of numeric GPIO ranges must be the empty string.\n",
                                                np);
                                        break;
                                }
                        }
                        /* npins != 0: linear range */
                        ret = gpiochip_add_pin_range(chip,
                                        pinctrl_dev_get_devname(pctldev),
                                        pinspec.args[0],
                                        pinspec.args[1],
                                        pinspec.args[2]);
                        if (ret)
                                return ret;
                } else {
                        /* npins == 0: special range */
                        if (pinspec.args[1]) {
                                pr_err("%pOF: Illegal gpio-range format.\n",
                                        np);
                                break;
                        }

                        if (!group_names) {
                                pr_err("%pOF: GPIO group range requested but no %s property.\n",
                                        np, group_names_propname);
                                break;
                        }

                        ret = of_property_read_string_index(np,
                                                group_names_propname,
                                                index, &name);
                        if (ret)
                                break;

                        if (!strlen(name)) {
                                pr_err("%pOF: Group name of GPIO group range cannot be the empty string.\n",
                                np);
                                break;
                        }

                        ret = gpiochip_add_pingroup_range(chip, pctldev,
                                                pinspec.args[0], name);
                        if (ret)
                                return ret;
                }
        }

        return 0;
}

#else
static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; }
#endif

“gpio-ranges” 속성을 사용하여 연계할 pin controller의 지정된 핀들을 gpio 컨트롤러에 등록한다.

  • 코드 라인 15에서 “gpio-ranges-group-names” 속성 값을 알아온다.
  • 코드 라인 17~21에서 “gpio-ranges” 속성이 배열로 지정될 수 있으므로 반복하며 읽는다.
  • 코드 라인 23~26에서 phandle 값으로 지정한 pin controller 디바이스를 알아온다.
  • 코드 라인 28~38에서 3개의 argument를 사용한 경우 “gpio-ranges-group-names” 속성 값이 사용된 경우 빈문자열이어야 한다.
  • 코드 라인 40~46에서 gpio chip 정보에 핀 range를 등록한다.
    • 첫 번째 인수부터 gpio 시작 번호(offset), pin 시작 번호(offset), gpio 개수이다.
  • 코드 라인 47~77에서 그 밖의 argument 개수를 사용한 경우 두 번째 인수는 항상 0이어야 한다.  “gpio-ranges-group-names” 속성이 반드시 사용되어야 하며 해당 그룹명을 읽어와서 그 그룹에 해당하는 pin들로 gpio chip 정보에 핀 range를 등록한다.

 

devprop_gpiochip_set_names()

drivers/gpio/gpiolib-devprop.c

/**
 * devprop_gpiochip_set_names - Set GPIO line names using device properties
 * @chip: GPIO chip whose lines should be named, if possible
 *
 * Looks for device property "gpio-line-names" and if it exists assigns
 * GPIO line names for the chip. The memory allocated for the assigned
 * names belong to the underlying firmware node and should not be released
 * by the caller.
 */
void devprop_gpiochip_set_names(struct gpio_chip *chip)
{
        struct gpio_device *gdev = chip->gpiodev;
        const char **names;
        int ret, i;

        if (!chip->parent) {
                dev_warn(&gdev->dev, "GPIO chip parent is NULL\n");
                return;
        }

        ret = device_property_read_string_array(chip->parent, "gpio-line-names",
                                                NULL, 0);
        if (ret < 0)
                return;

        if (ret != gdev->ngpio) {
                dev_warn(chip->parent,
                         "names %d do not match number of GPIOs %d\n", ret,
                         gdev->ngpio);
                return;
        }

        names = kcalloc(gdev->ngpio, sizeof(*names), GFP_KERNEL);
        if (!names)
                return;

        ret = device_property_read_string_array(chip->parent, "gpio-line-names",
                                                names, gdev->ngpio);
        if (ret < 0) {
                dev_warn(chip->parent, "failed to read GPIO line names\n");
                kfree(names);
                return;
        }

        for (i = 0; i < gdev->ngpio; i++)
                gdev->descs[i].name = names[i];

        kfree(names);
}

gpio controller 노드에서 gpio 이름이 주어지지 않은 경우 부모 gpio controller 노드의 “gpio-line-names” 속성 값들을 읽어서 gpio 디스크립터들에서 gpio명으로 사용한다.

  • gpio  controller 노드에서 “X-gpios ” 속성을 사용하지 않은 경우 “gpio-line-names” 속성에서 지정한 이름들을 사용한다.

 

  • 코드 라인 16~19에서 부모 gpio controller가 없는 경우 경고 메시지를 출력 후 함수를 빠져나간다.
  • 코드 라인 21~24에서 부모 gpio controller 노드에서 “gpio-line-names” 속성을 찾아 없으면 함수를 빠져나간다.
  • 코드 라인 26~31에서 gpio 컨트롤러에 등록된 gpio 수와 “gpio-line-names” 속성에서 읽어들인 개수가 다르면 경고 메시지를 출력 후 함수를 빠져나간다.
  • 코드 라인 33~35에서 “gpio-line-names” 속성에서 읽은 라인 명 개수 만큼 문자열 포인터 배열을 준비한다.
  • 코드 라인 37~46에서 “gpio-line-names” 속성에서 문자열을 읽어 names[] 배열에 대입하게 한다. 그 후 그 수 만큼 gpio 디바이스의 디스크립터들 이름으로 지정한다.

 

of_gpiochip_scan_gpios()

drivers/gpio/gpiolib-of.c

/**
 * of_gpiochip_scan_gpios - Scan gpio-controller for gpio definitions
 * @chip:       gpio chip to act on
 *
 * This is only used by of_gpiochip_add to request/set GPIO initial
 * configuration.
 * It returns error if it fails otherwise 0 on success.
 */
static int of_gpiochip_scan_gpios(struct gpio_chip *chip)
{
        struct gpio_desc *desc = NULL;
        struct device_node *np;
        const char *name;
        enum gpio_lookup_flags lflags;
        enum gpiod_flags dflags;
        unsigned int i;
        int ret;

        for_each_available_child_of_node(chip->of_node, np) {
                if (!of_property_read_bool(np, "gpio-hog"))
                        continue;

                for (i = 0;; i++) {
                        desc = of_parse_own_gpio(np, chip, i, &name, &lflags,
                                                 &dflags);
                        if (IS_ERR(desc))
                                break;

                        ret = gpiod_hog(desc, name, lflags, dflags);
                        if (ret < 0) {
                                of_node_put(np);
                                return ret;
                        }
                }
        }

        return 0;
}

gpio controller 노드의 서브 노드들에서 “gpio_hog” 속성이 발견되면 지정된 gpio 핀 상태를 즉시 설정한다.

  • 코드 라인 19~21에서 gpio controller 노드의 서브 노드들에서 “gpio_hog” 속성이 발견되지 않으면 skip 한다.
  • 코드 라인 23~27에서 gpio hog 노드를 파싱하여 이름을 name에 대입하고, 로지컬 플래그 lflags에 대입한다. 그리고 파싱한 디렉션 플래그를 dflags에 대입한다.
  • 코드 라인 29~30에서 gpio controller 디바이스를 통해 위에서 파싱한 정보를 HW에 설정한다.

 

of_parse_own_gpio()

drivers/gpio/gpiolib-of.c

/**
 * of_parse_own_gpio() - Get a GPIO hog descriptor, names and flags for GPIO API
 * @np:         device node to get GPIO from
 * @chip:       GPIO chip whose hog is parsed
 * @idx:        Index of the GPIO to parse
 * @name:       GPIO line name
 * @lflags:     gpio_lookup_flags - returned from of_find_gpio() or
 *              of_parse_own_gpio()
 * @dflags:     gpiod_flags - optional GPIO initialization flags
 *
 * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
 * value on the error condition.
 */
static struct gpio_desc *of_parse_own_gpio(struct device_node *np,
                                           struct gpio_chip *chip,
                                           unsigned int idx, const char **name,
                                           enum gpio_lookup_flags *lflags,
                                           enum gpiod_flags *dflags)
{
        struct device_node *chip_np;
        enum of_gpio_flags xlate_flags;
        struct of_phandle_args gpiospec;
        struct gpio_desc *desc;
        unsigned int i;
        u32 tmp;
        int ret;

        chip_np = chip->of_node;
        if (!chip_np)
                return ERR_PTR(-EINVAL);

        xlate_flags = 0;
        *lflags = 0;
        *dflags = 0;

        ret = of_property_read_u32(chip_np, "#gpio-cells", &tmp);
        if (ret)
                return ERR_PTR(ret);

        gpiospec.np = chip_np;
        gpiospec.args_count = tmp;

        for (i = 0; i < tmp; i++) {
                ret = of_property_read_u32_index(np, "gpios", idx * tmp + i,
                                                 &gpiospec.args[i]);
                if (ret)
                        return ERR_PTR(ret);
        }

        desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, &xlate_flags);
        if (IS_ERR(desc))
                return desc;

        if (xlate_flags & OF_GPIO_ACTIVE_LOW)
                *lflags |= GPIO_ACTIVE_LOW;

        if (of_property_read_bool(np, "input"))
                *dflags |= GPIOD_IN;
        else if (of_property_read_bool(np, "output-low"))
                *dflags |= GPIOD_OUT_LOW;
        else if (of_property_read_bool(np, "output-high"))
                *dflags |= GPIOD_OUT_HIGH;
        else {
                pr_warn("GPIO line %d (%s): no hogging state specified, bailing out\n",
                        desc_to_gpio(desc), np->name);
                return ERR_PTR(-EINVAL);
        }

        if (name && of_property_read_string(np, "line-name", name))
                *name = np->name;

        return desc;
}

gpio hog 노드를 파싱하여 출력 인자 3개에 결과를 대입하고 해당 디스크립터를 찾아온다. 자세한 것은 다음과 같다.

  • “line-name” 속성 값을 출력 인자 name에 대입
  • “gpios” 속성값을 파싱하여 디스크립터를 찾아 반환하고, 파싱한 설정 값에 OF_GPIO_ACTIVE_LOW(1) 플래그가 발견되면 로지컬 플래그에 해당하는 출력 인자 lflags에 GPIO_ACTIVE_LOW(1)를 대입
  • “input”, “output-low”, “output-high” 속성 중 하나에 해당하는 플래그 비트를 디렉션 플래그에 해당하는 출력인자 dflags에 대입

 

  • 코드 라인 28~30에서 gpio controller에 해당하는 노드가 없으면 에러로 함수를 빠져나간다.
  • 코드 라인 36~42에서 gpio controller 노드에서 “#gpio-cells” 속성 값을 알아와서 argument 정보를 설정한다.
  • 코드 라인 44~49에서 hog 노드에서 argument 수 만큼 “gpios” 속성 값을 읽어서 이 역시 argument 정보에 설정한다.
  • 코드 라인 51~53에서 hog 노드에서 “gpios”의 argument를 파싱하여 시작 gpio 번호와 파싱된 플래그 값을 xlate_flags에 대입한다.
  • 코드 라인 55~56에서 읽어온 xlate_flags에 ACTIVE_LOW(1) 플래그가 담겨 있으면 lflags에 설정한다.
  • 코드 라인 58~68에서 “input”, “output-low” 그리고 “output-high”와 같은 세가지 속성 중 하나를 찾아 dflags에 대입한다. 발견하지 못하면 경고 메시지를 출력하고 에러로 함수를 빠져나간다.
  • 코드 라인 70~73에서 “line-name” 속성을 찾아 출력 인자 name에 대입한 후 디스크립터를 반환한다.
    • 이 이름은 추후 gpio 디스크립터의 label로 지정된다.

 

gpiod_hog()

drivers/gpio/gpiolib-of.c

/**
 * gpiod_hog - Hog the specified GPIO desc given the provided flags
 * @desc:       gpio whose value will be assigned
 * @name:       gpio line name
 * @lflags:     gpio_lookup_flags - returned from of_find_gpio() or
 *              of_get_gpio_hog()
 * @dflags:     gpiod_flags - optional GPIO initialization flags
 */
int gpiod_hog(struct gpio_desc *desc, const char *name,
              unsigned long lflags, enum gpiod_flags dflags)
{
        struct gpio_chip *chip;
        struct gpio_desc *local_desc;
        int hwnum;
        int status;

        chip = gpiod_to_chip(desc);
        hwnum = gpio_chip_hwgpio(desc);

        local_desc = gpiochip_request_own_desc(chip, hwnum, name);
        if (IS_ERR(local_desc)) {
                status = PTR_ERR(local_desc);
                pr_err("requesting hog GPIO %s (chip %s, offset %d) failed, %d\n",
                       name, chip->label, hwnum, status);
                return status;
        }

        status = gpiod_configure_flags(desc, name, lflags, dflags);
        if (status < 0) {
                pr_err("setup of hog GPIO %s (chip %s, offset %d) failed, %d\n",
                       name, chip->label, hwnum, status);
                gpiochip_free_own_desc(desc);
                return status;
        }

        /* Mark GPIO as hogged so it can be identified and removed later */
        set_bit(FLAG_IS_HOGGED, &desc->flags);

        pr_info("GPIO line %d (%s) hogged as %s%s\n",
                desc_to_gpio(desc), name,
                (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input",
                (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ?
                  (dflags&GPIOD_FLAGS_BIT_DIR_VAL) ? "/high" : "/low":"");

        return 0;
}

hog 노드를 파싱하여 얻은 인자들을 gpio conrtroller를 통해 H/W 설정한다.

  • 코드 라인 17~26에서 gpio 디스크립터로 gpio controller와 hwgpio 번호를 알아온다. 그 후 이에 해당하는 로컬 gpio 디스크립터를 알아온다.
  • 코드 라인 28~34에서 룩업 플래그(lflags)에 설정된 플래그들을 gpio 디스크립터에도 추가 반영한다. 또한 디렉션 플래그dflags)에 따라 gpio 입/출력 모드를 HW에 설정한다.
  • 코드 라인37~45에서 gpio 디스크립터에 hog 처리 플래그를 추가하고 hog 정보를 출력한 후 성공(0)을 반환한다.

 

디바이스 트리를 사용한 gpio 디스크립터 검색

of_find_gpio()

drivers/gpio/gpiolib-of.c

struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
                   unsigned int idx,
                   enum gpio_lookup_flags *flags)
{
    char prop_name[32]; /* 32 is max size of property name */
    enum of_gpio_flags of_flags;
    struct gpio_desc *desc;
    unsigned int i;

    for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
        if (con_id)
            snprintf(prop_name, sizeof(prop_name), "%s-%s", con_id,
                 gpio_suffixes[i]);
        else
            snprintf(prop_name, sizeof(prop_name), "%s",
                 gpio_suffixes[i]);

        desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
                        &of_flags);
        if (!IS_ERR(desc) || (PTR_ERR(desc) != -ENOENT))
            break;
    }

    if (IS_ERR(desc))
        return desc;

    if (of_flags & OF_GPIO_ACTIVE_LOW)
        *flags |= GPIO_ACTIVE_LOW;

    if (of_flags & OF_GPIO_SINGLE_ENDED) {
        if (of_flags & OF_GPIO_OPEN_DRAIN)
            *flags |= GPIO_OPEN_DRAIN;
        else
            *flags |= GPIO_OPEN_SOURCE;
    }

    if (of_flags & OF_GPIO_SLEEP_MAY_LOOSE_VALUE)
        *flags |= GPIO_SLEEP_MAY_LOOSE_VALUE;

    return desc;
}

지정한 디바이스 트리 노드에서 인자로 전달 받은 con_id 문자열과 관련된 속성명을 파싱하여 gpio 디스크립터를 찾아온다.

  • 코드 라인 10~25에서 인자로 전달받은 디바이스 노드에서 “<con_id>-gpios” 및 “<con_id>-gpio” 속성명으로 검색한다.
    • <con_id>가 없는 경우 특정 Consumer 디바이스용이 아닌 글로벌 용도 이므로 “gpios” 및 “gpio” 속성명으로 검색한다.
  • 코드 라인 27~28에서 디바이스 트리 노드에서 파싱한 플래그 값이 low active 방식을 사용하는 경우 출력 인자 flags에도 GPIO_ACTIVE_LOW 플래그를 추가한다.
  • 코드 라인 30~35에서 디바이스 트리 노드에서 MOSFET 구성이 push-pull이 아니라 single ended 방식인 경우 파싱한 플래그 값이 open drain 사용 유무에 따라 출력 인자 flags에도 open drain 또는 open source 플래그를 추가한다.
  • 코드 라인 37~38에서 디바이스 트리 노드에서 파싱한 플래그 값이 sleep시 value를 잃어버린다고 설정되어 있는 경우 출력 인자 flags에도 플래그를 추가한다.

 

/**
 * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API
 * @np:     device node to get GPIO from
 * @propname:   property name containing gpio specifier(s)
 * @index:  index of the GPIO
 * @flags:  a flags pointer to fill in
 *
 * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
 * value on the error condition. If @flags is not NULL the function also fills
 * in flags for the GPIO.
 */
struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np,
             const char *propname, int index, enum of_gpio_flags *flags)
{
    struct of_phandle_args gpiospec;
    struct gpio_chip *chip;
    struct gpio_desc *desc;
    int ret;

    ret = of_parse_phandle_with_args(np, propname, "#gpio-cells", index,
                     &gpiospec);
    if (ret) {
        pr_debug("%s: can't parse '%s' property of node '%pOF[%d]'\n",
            __func__, propname, np, index);
        return ERR_PTR(ret);
    }

    chip = of_find_gpiochip_by_xlate(&gpiospec);
    if (!chip) {
        desc = ERR_PTR(-EPROBE_DEFER);
        goto out;
    }

    desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, flags);
    if (IS_ERR(desc))
        goto out;

    pr_debug("%s: parsed '%s' property of node '%pOF[%d]' - status (%d)\n",
         __func__, propname, np, index,
         PTR_ERR_OR_ZERO(desc));

out:
    of_node_put(gpiospec.np);

    return desc;
}

요청한 디바이스 노드(gpio controller 노드)의 “#gpio-cells” 속성 값의 argument 수 만큼 벤더가 제공하는 변환 함수(*of_xlate)를 사용하여 gpio핀 번호와 플래그를 변환한 후 해당 gpiochip에서 디스크립터를 찾아 반환한다. 출력 인자 flags 값에도 반환시킨다.

  • two cell을 사용하는 simple 변환 사용 예) “abc-gpios” = <&gpio 12 0>
    • 12번 gpio에서 0번 설정 값을 플래그에 대입한다.
    • 참고로 4 bit 플래그 값이 모두 0이므로 -> high-active, push-pull, sleep-maintain-value 특성을 가진다.

 

  • 코드 라인 20~26에서 인자로 요청한 프로퍼티명(X-gpios, X-gpio, gpios, gpio)에서 index 배열의 argument를 읽어서 출력 인자 gpiospec에 대입한다.
    • 예) “abc-gpios” = <&gpio 12 0>, <&gpio 13, 0>에서 propname=”abc-gpios”, index=1로 검색 요청을 한 경우
      • -> index=0을 건너띄고 <&gpio 13, 0> 값을 읽어 gpiospec argument에 대입한다.
  • 코드 라인 28~32에서 첫 번째 argument는 gpio controller 노드를 가리키는 phandle 값이다. 이 phandle로 노드를 검색하여 해당하는  gpio_chip 구조체를 찾아온다.
  • 코드 라인 34~36에서 argument 값을 변환한 값에 해당하는 gpio 디스크립터 및 플래그 값을 알아온다.

 

of_xlate_and_get_gpiod_flags()

drivers/gpio/gpiolib-of.c

static struct gpio_desc *of_xlate_and_get_gpiod_flags(struct gpio_chip *chip,
                    struct of_phandle_args *gpiospec,
                    enum of_gpio_flags *flags)
{
    int ret;

    if (chip->of_gpio_n_cells != gpiospec->args_count)
        return ERR_PTR(-EINVAL);

    ret = chip->of_xlate(chip, gpiospec, flags);
    if (ret < 0)
        return ERR_PTR(ret);

    return gpiochip_get_desc(chip, ret);
}

인자로 전달받은 gpio argument들을 사용하여 GPIO 칩 벤더가 제공하는 (*of_xlate) 변환 함수를 통해 알아온 gpio hw pin 번호와 플래그 값을 사용하여 gpio 디스크립터를 찾아 반환한다.

  • 대부분의gpio controller에서 (*of_xlate) 후크 구현 시 of_gpio_simple_xlate() 함수를 사용한다. 이 함수는 phandle 뒤에 위치하는 두 개의 argument 값을 변환 없이 그대로 gpio 번호와 gpio 플래그 값으로 반환한다.
    • 예) <gpio hw pin: 0~> <flags>
  • 특정 gpio controller는 세 개의 argument를 사용하는 경우도 있으므로 반드시 확인하여 구별해야 한다. 보통 이러한 경우 추가된 인자는 뱅GPIO 뱅크를 가리킨다.
    • 예) <gpio bank: 0~> <gpio hw pin: 0~31> <flags>
  • 코드 라인 7~8에서 gpio controller에 지정된 cell 수와 인자로 전달받은 augument 인자 수가 다른 경우 에러로 함수를 빠져나간다.
  • 코드 라인 10~12에서 gpio controller의 (*of_xlate) 후크에 등록된 함수를 수행한다.
    • 벤더가 후크 함수를 제공하지 않으면 디폴트로 of_gpio_simple_xlate() 함수를 사용한다.
    • phandle 값 뒤에 3개의 argument들을 요구하는 벤더를 제외하면, 2개의 argument들을 요구하는 대부분의 벤더는 별도의 후크 함수를 제공하지 않는다.
  • 코드 라인 14에서 해당 결과 인덱스에 해당하는 gpio 디스크립터를 반환한다.

 

다음 그림은 gpios 속성의 phandle 뒤에 사용된 argument 수에 따라 gpio 칩 벤더가 제공하는 (*xlate) 함수의 사용사례를 보여준다.

 

 

of_gpio_simple_xlate()

drivers/gpio/gpiolib-of.c

/**
 * of_gpio_simple_xlate - translate gpiospec to the GPIO number and flags
 * @gc:         pointer to the gpio_chip structure
 * @gpiospec:   GPIO specifier as found in the device tree
 * @flags:      a flags pointer to fill in
 *
 * This is simple translation function, suitable for the most 1:1 mapped
 * GPIO chips. This function performs only one sanity check: whether GPIO
 * is less than ngpios (that is specified in the gpio_chip).
 */
int of_gpio_simple_xlate(struct gpio_chip *gc,
                         const struct of_phandle_args *gpiospec, u32 *flags)
{
        /*
         * We're discouraging gpio_cells < 2, since that way you'll have to
         * write your own xlate function (that will have to retrieve the GPIO
         * number and the flags from a single gpio cell -- this is possible,
         * but not recommended).
         */
        if (gc->of_gpio_n_cells < 2) {
                WARN_ON(1);
                return -EINVAL;
        }

        if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
                return -EINVAL;

        if (gpiospec->args[0] >= gc->ngpio)
                return -EINVAL;

        if (flags)
                *flags = gpiospec->args[1];

        return gpiospec->args[0];
}
EXPORT_SYMBOL(of_gpio_simple_xlate);

2개의 셀을 사용하는 goio simple 변환은 gpio 시작 번호(offset)에 해당하는 첫 번째 argument를 그대로 반환한다. 그리고 gpio 설정 값에 해당하는 두 번째 인수 역시 그대로 변환 없이 출력 인자 flags에 대입한다.

  • 코드 라인 20~23에서 셀수가 2개보다 작으면 simple 셀 변환을 할 수 없어서 경고 메시지를 출력하고 에러를 반환한다.
  • 코드 라인 25~26에서 필요한 인자 개수가 모자라면 역시 에러를 반환한다.
  • 코드 라인 28~29에서 gpio 시작 번호(offset)에 해당하는 첫 번째 argument가 gpio 컨트롤러에 등록된 gpio 수를 초과하면 처리할 수 없으므로 에러를 반환한다.
  • 코드 라인 31~32에서 gpio 설정 값에 해당하는 두 번째 인수는 그대로 변환 없이 출력 인자 flags에 대입한다.
  • 코드 라인 34에서 gpio 시작 번호(offset)에 해당하는 첫 번째 argument를 변환 없이 그대로 반환한다.

 

참고

 

 

GPIO Subsystem -2-

문영일 Leave a comment

 

GPIO Controller 디바이스 드라이버

최근에는 GPIO 디바이스 드라이버가 독립적으로 작성되지 않고, Pin Controller 디바이스 드라이버 내부에 Pin Control 디바이스 드라이버와 GPIO 디바이스 드라이버 코드가 동시에 포함되어 구현되는 추세이다.

 

드라이버 시작

GPIO 컨트롤러가 어떤 버스뒤에 붙어 있는지에 따라서 다음 어느 형태의 드라이버 뒤에 붙일지 고려해야 한다.

  • 플랫폼 드라이버
    • module_platform_driver() 또는 platform_driver_register()
  • pci 드라이버
    • module_pci_driver()
  • i2 드라이버
    • module_i2c_driver() 또는 i2c_add_driver()

 

broadcom ns2 소스 예

drivers/pinctrl/bcm/pinctrl-iproc-gpio.c

static struct platform_driver iproc_gpio_driver = {
        .driver = {
                .name = "iproc-gpio",
                .of_match_table = iproc_gpio_of_match,
        },
        .probe = iproc_gpio_probe,
};

static int __init iproc_gpio_init(void)
{
        return platform_driver_register(&iproc_gpio_driver);
}
arch_initcall_sync(iproc_gpio_init);

 

GPIO 디바이스 등록

broadcom ns, ns2, stingray 칩 계열의 gpio controller를 등록한다. gpio 내부에서 인터럽트 처리도 하므로 관련된 irq_chip도 준비하여 등록한다.

iproc_gpio_probe()

drivers/pinctrl/bcm/pinctrl-iproc-gpio.c -1/2-

static int iproc_gpio_probe(struct platform_device *pdev)
{
        struct device *dev = &pdev->dev;
        struct resource *res;
        struct iproc_gpio *chip;
        struct gpio_chip *gc;
        u32 ngpios, pinconf_disable_mask = 0;
        int irq, ret;
        bool no_pinconf = false;

        /* NSP does not support drive strength config */
        if (of_device_is_compatible(dev->of_node, "brcm,iproc-nsp-gpio"))
                pinconf_disable_mask = BIT(IPROC_PINCONF_DRIVE_STRENGTH);
        /* Stingray does not support pinconf in this controller */
        else if (of_device_is_compatible(dev->of_node,
                                         "brcm,iproc-stingray-gpio"))
                no_pinconf = true;

        chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
        if (!chip)
                return -ENOMEM;

        chip->dev = dev;
        platform_set_drvdata(pdev, chip);

        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        chip->base = devm_ioremap_resource(dev, res);
        if (IS_ERR(chip->base)) {
                dev_err(dev, "unable to map I/O memory\n");
                return PTR_ERR(chip->base);
        }

        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
        if (res) {
                chip->io_ctrl = devm_ioremap_resource(dev, res);
                if (IS_ERR(chip->io_ctrl)) {
                        dev_err(dev, "unable to map I/O memory\n");
                        return PTR_ERR(chip->io_ctrl);
                }
        }

        if (of_property_read_u32(dev->of_node, "ngpios", &ngpios)) {
                dev_err(&pdev->dev, "missing ngpios DT property\n");
                return -ENODEV;
        }
  • 코드 라인 12~13에서 “brcm,iproc-nsp-gpio” gpio 드라이버를 사용하는 칩(ns, ns2)은 drive-strength를 설정할 수 없다.
  • 코드 라인 15~17에서 “brcm,iproc-stingray-gpio” 드라이버를  사용하는 칩(stingray)은 pinconf를 사용할 수 없다.
  • 코드 라인 19~24에서 벤더의 gpio chip 정보를 구성하기 위한 구조체를 할당하고 이 구조체를 플랫폼 디바이스와 연결한다.
  • 코드 라인 26~40에서 첫 번째와 두 번째 플랫폼 리소스를 알아와서 io 매핑한다.
  • 코드 라인 42~45에서 디바이스 트리 노드의 “ngpios” 속성을 읽어 전체 gpio 핀 수를 알아온다.

 

drivers/pinctrl/bcm/pinctrl-iproc-gpio.c -2/2-

        raw_spin_lock_init(&chip->lock);

        gc = &chip->gc;
        gc->base = -1;
        gc->ngpio = ngpios;
        chip->num_banks = (ngpios + NGPIOS_PER_BANK - 1) / NGPIOS_PER_BANK;
        gc->label = dev_name(dev);
        gc->parent = dev;
        gc->of_node = dev->of_node;
        gc->request = iproc_gpio_request;
        gc->free = iproc_gpio_free;
        gc->direction_input = iproc_gpio_direction_input;
        gc->direction_output = iproc_gpio_direction_output;
        gc->set = iproc_gpio_set;
        gc->get = iproc_gpio_get;

        chip->pinmux_is_supported = of_property_read_bool(dev->of_node,
                                                        "gpio-ranges");

        ret = gpiochip_add_data(gc, chip);
        if (ret < 0) {
                dev_err(dev, "unable to add GPIO chip\n");
                return ret;
        }

        if (!no_pinconf) {
                ret = iproc_gpio_register_pinconf(chip);
                if (ret) {
                        dev_err(dev, "unable to register pinconf\n");
                        goto err_rm_gpiochip;
                }

                if (pinconf_disable_mask) {
                        ret = iproc_pinconf_disable_map_create(chip,
                                                         pinconf_disable_mask);
                        if (ret) {
                                dev_err(dev,
                                        "unable to create pinconf disable map\n");
                                goto err_rm_gpiochip;
                        }
                }
        }

        /* optional GPIO interrupt support */
        irq = platform_get_irq(pdev, 0);
        if (irq) {
                ret = gpiochip_irqchip_add(gc, &iproc_gpio_irq_chip, 0,
                                           handle_simple_irq, IRQ_TYPE_NONE);
                if (ret) {
                        dev_err(dev, "no GPIO irqchip\n");
                        goto err_rm_gpiochip;
                }

                gpiochip_set_chained_irqchip(gc, &iproc_gpio_irq_chip, irq,
                                             iproc_gpio_irq_handler);
        }

        return 0;

err_rm_gpiochip:
        gpiochip_remove(gc);

        return ret;
}
  • 코드 라인 1~15에서 gpiochip에 대한 스핀락을 획득한 채로 gpiochip에 대한 정보 및 오퍼레이션 후크 함수들을 지정한다.
    • num_banks는 총 지원되는 gpio 핀 수를 32개 단위로 round-up한 수이다.
      • 예) ngpios=66 -> num_banks=3
    • 후크 함수 6개가 지정되었고, 그 중 (*request) 및 (*free) 후크 함수는 pin controller의 pinmux와 연계시켰다.
  • 코드 라인 17~18에서 gpio 디바이스 노드에서 “gpio-ranges” 속성이 발견되면 pinmux와의 연동이 있도록 gpiochip 멤버 pinmux_is_supported를 설정한다.
  • 코드 라인 20~24에서 gpiochip을 등록한다.
  • 코드 라인 26~42에서 pinconf가 지원되는 칩(ns, ns2)인 경우 pin controller(&iproc_pctrl_ops, &iproc_pconf_ops 오퍼레이션) 구현들을 등록시킨다.
    • pinconf 설정 항목 중 지원되지 않는 것들을 위해 disable 항목들을 매핑한다. pinconf가 지원하는 항목은 다음과 같다.
      • drive-strength (ns, ns2는 지원하지 않으므로 disable 매핑시킨다.)
      • bias-disable
      • bias-pull-up
      • bias-pull-down
  • 코드 라인 45~56에서 플랫폼 데이터를 통해 parent irq를 알아온다. gpio용 interrupt controller 기능에 대응하려고 전역에 준비해둔 iproc_gpio_irq_chip을 등록하고 parent irq에 체인으로 연결한다.

 

GPIO Controller 등록(gpio_chip)

아래 그림은 두 개의 gpio 핀을 갖는 gpio controller를 등록할 때의 모습을 보여준다.

 

gpiochip_add_data()

drivers/gpio/gpiolib.c -1/4-

/**
 * gpiochip_add_data() - register a gpio_chip
 * @chip: the chip to register, with chip->base initialized
 * @data: driver-private data associated with this chip
 *
 * Context: potentially before irqs will work
 *
 * When gpiochip_add_data() is called very early during boot, so that GPIOs
 * can be freely used, the chip->parent device must be registered before
 * the gpio framework's arch_initcall().  Otherwise sysfs initialization
 * for GPIOs will fail rudely.
 *
 * gpiochip_add_data() must only be called after gpiolib initialization,
 * ie after core_initcall().
 *
 * If chip->base is negative, this requests dynamic assignment of
 * a range of valid GPIOs.
 *
 * Returns:
 * A negative errno if the chip can't be registered, such as because the
 * chip->base is invalid or already associated with a different chip.
 * Otherwise it returns zero as a success code.
 */
int gpiochip_add_data(struct gpio_chip *chip, void *data)
{
        unsigned long   flags;
        int             status = 0;
        unsigned        i;
        int             base = chip->base;
        struct gpio_device *gdev;

        /*
         * First: allocate and populate the internal stat container, and
         * set up the struct device.
         */
        gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
        if (!gdev)
                return -ENOMEM;
        gdev->dev.bus = &gpio_bus_type;
        gdev->chip = chip;
        chip->gpiodev = gdev;
        if (chip->parent) {
                gdev->dev.parent = chip->parent;
                gdev->dev.of_node = chip->parent->of_node;
        }

#ifdef CONFIG_OF_GPIO
        /* If the gpiochip has an assigned OF node this takes precedence */
        if (chip->of_node)
                gdev->dev.of_node = chip->of_node;
#endif

        gdev->id = ida_simple_get(&gpio_ida, 0, 0, GFP_KERNEL);
        if (gdev->id < 0) {
                status = gdev->id;
                goto err_free_gdev;
        }
        dev_set_name(&gdev->dev, "gpiochip%d", gdev->id);
        device_initialize(&gdev->dev);
        dev_set_drvdata(&gdev->dev, gdev);
        if (chip->parent && chip->parent->driver)
                gdev->owner = chip->parent->driver->owner;
        else if (chip->owner)
                /* TODO: remove chip->owner */
                gdev->owner = chip->owner;
        else
                gdev->owner = THIS_MODULE;
  • 코드 라인 37~46에서 gpio_device 구조체를 할당한 후 인자로 전달받은 gpiochip을 연결시킨다.
  • 코드 라인 48~52에서 chip에 있는 디바이스 노드 정보도 gpio_device에 연결한다.
  • 코드 라인 53~57에서 gpio_device에 사용할 id는 Radix tree로 관리하는 IDA를 통해 할당받는다.
    • 처음 시작 시 0번 부터 할당받는다.
  • 코드 라인 58에서 gpio 디바이스의 이름으로 “gpiochip<id>”를 사용한다.
    • 처음 시작 시 gpio controller 디바이스는 “gpiochip0” 이라는 이름을 갖는다.
  • 코드 라인 59~67에서 gpio 디바이스의 초기 설정을 준비한다.

 

drivers/gpio/gpiolib.c -2/4-

        gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
        if (!gdev->descs) {
                status = -ENOMEM;
                goto err_free_gdev;
        }

        if (chip->ngpio == 0) {
                chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
                status = -EINVAL;
                goto err_free_descs;
        }

        if (chip->label)
                gdev->label = kstrdup(chip->label, GFP_KERNEL);
        else
                gdev->label = kstrdup("unknown", GFP_KERNEL);
        if (!gdev->label) {
                status = -ENOMEM;
                goto err_free_descs;
        }

        gdev->ngpio = chip->ngpio;
        gdev->data = data;

        spin_lock_irqsave(&gpio_lock, flags);

        /*
         * TODO: this allocates a Linux GPIO number base in the global
         * GPIO numberspace for this chip. In the long run we want to
         * get *rid* of this numberspace and use only descriptors, but
         * it may be a pipe dream. It will not happen before we get rid
         * of the sysfs interface anyways.
         */
        if (base < 0) {
                base = gpiochip_find_base(chip->ngpio);
                if (base < 0) {
                        status = base;
                        spin_unlock_irqrestore(&gpio_lock, flags);
                        goto err_free_label;
                }
                /*
                 * TODO: it should not be necessary to reflect the assigned
                 * base outside of the GPIO subsystem. Go over drivers and
                 * see if anyone makes use of this, else drop this and assign
                 * a poison instead.
                 */
                chip->base = base;
        }
        gdev->base = base;

        status = gpiodev_add_to_list(gdev);
        if (status) {
                spin_unlock_irqrestore(&gpio_lock, flags);
                goto err_free_label;
        }

        spin_unlock_irqrestore(&gpio_lock, flags);
  • 코드 라인 1~11에서 gpio controller가 다룰 gpio 개수 만큼 gpio 디스크립터를 생성한다.
  • 코드 라인 13~20에서 gpio 디바이스 이름으로 gpiochip에 부여된 label 명을 복제하여 사용한다. 만일 지정되지 않은 경우 “unknown”이라는 이름을 사용한다.
  • 코드 라인 22~23에서 gpio 디바이스에 gpio 개수와 인자로 전달받은 custom gpio data 정보를 연결한다.
  • 코드 라인 25~57에서 gpio_lock 스핀 락을 획득한 채로 이 gpiochip이 다루는 gpio 개수만큼 들어갈 수 있는 공간의 시작 번호인 base 번호를 알아온다. 그런 후 글로벌 gpiochip 리스트에 추가한다.
    • 공간을 찾을 때 gpio 번호들이 gpio controller 간에 중첩되지 않도록 한다.

 

drivers/gpio/gpiolib.c -3/4-

        for (i = 0; i < chip->ngpio; i++) {
                struct gpio_desc *desc = &gdev->descs[i];

                desc->gdev = gdev;
                /*
                 * REVISIT: most hardware initializes GPIOs as inputs
                 * (often with pullups enabled) so power usage is
                 * minimized. Linux code should set the gpio direction
                 * first thing; but until it does, and in case
                 * chip->get_direction is not set, we may expose the
                 * wrong direction in sysfs.
                 */

                if (chip->get_direction) {
                        /*
                         * If we have .get_direction, set up the initial
                         * direction flag from the hardware.
                         */
                        int dir = chip->get_direction(chip, i);

                        if (!dir)
                                set_bit(FLAG_IS_OUT, &desc->flags);
                } else if (!chip->direction_input) {
                        /*
                         * If the chip lacks the .direction_input callback
                         * we logically assume all lines are outputs.
                         */
                        set_bit(FLAG_IS_OUT, &desc->flags);
                }
        }

#ifdef CONFIG_PINCTRL
        INIT_LIST_HEAD(&gdev->pin_ranges);
#endif

        status = gpiochip_set_desc_names(chip);
        if (status)
                goto err_remove_from_list;

        status = gpiochip_irqchip_init_valid_mask(chip);
        if (status)
                goto err_remove_from_list;

        status = of_gpiochip_add(chip);
        if (status)
                goto err_remove_chip;

        acpi_gpiochip_add(chip);

        /*
         * By first adding the chardev, and then adding the device,
         * we get a device node entry in sysfs under
         * /sys/bus/gpio/devices/gpiochipN/dev that can be used for
         * coldplug of device nodes and other udev business.
         * We can do this only if gpiolib has been initialized.
         * Otherwise, defer until later.
         */
        if (gpiolib_initialized) {
                status = gpiochip_setup_dev(gdev);
                if (status)
                        goto err_remove_chip;
        }
        return 0;
  • 코드 라인 1~30에서 gpiochip이 다루는 gpio 개수 만큼 gpio 디스크립터를 초기화한다.
    • gpio controller가 HW 레지스터를 읽어 현재 해당 gpio 핀의 입/출력 모드를 읽어와서 FLAG_IS_OUT 플래그 비트에 설정한다.
      • direction 방향은 0=출력, 1=입력이다.
    • 만일 controller가 direction을 알아오는 기능이 없는 경우 출력 모드로 가정하고 FLAG_IS_OUT 플래그 비트를 설정한다.
  • 코드 라인 32~34에서 만일 커널에서 pin controller 기능이 설정된 경우 pin controller에서 요청한 gpio_range가 담길 리스트인 pin_ranges를 초기화한다.
    • gpiochip_add_pin_range() 함수 및 gpiochip_add_pingroup_range() 함수에서 추가된다.
  • 코드 라인 36~38에서 gpiochip에 등록되어 있는 gpio 이름들(gc->names)을 gpio 디스크립터 이름에 차례로 부여한다.
    • 중복되는 이름은 경고 메시지가 출력된다.
  • 코드 라인 40~42에서 gpiochip이 다루는 gpio의 모든 핀이 irq가 동작 가능한 상태로 irq valid mask를 할당하고 이들 비트들을 모두 valid 상태로 설정한다.
  • 코드 라인 44~46에서 gpio controller 오퍼레이션을 포함한 gpio_chip 구조체를 등록하고 디바이스 트리의 gpio controller 노드에서 각종 속성들을 파싱하여 처리한다. 디바이스 트리 노드가 없으면 성공(0) 결과로 다음 처리를 계속 한다.
  • 코드 라인 48에서 acpi_gpio를 할당 후 gpio controller 오퍼레이션을 포함한 gpio_chip 구조체를 등록하고 ACPI 테이블을 스캔 후 각종 속성들을 파싱하여 처리한다. ACPI가 지원되지 않는 경우 아무것도 처리하지 않는다.
  • 코드 라인 58~62에서 gpiolib가 초기화된 경우 gpiochip을 캐릭터 디바이스로 등록하고 sysfs bus에 노출시킨다.
    • core_initcall(gpiolib_dev_init) 함수를 통해 GPIO sysfs bus에 gpio 캐릭터 디바이스가 등록된 후에 전역 변수 gpiolib_initialized가 true로 설정된다.

 

drivers/gpio/gpiolib.c -4/4-

err_remove_chip:
        acpi_gpiochip_remove(chip);
        gpiochip_free_hogs(chip);
        of_gpiochip_remove(chip);
        gpiochip_irqchip_free_valid_mask(chip);
err_remove_from_list:
        spin_lock_irqsave(&gpio_lock, flags);
        list_del(&gdev->list);
        spin_unlock_irqrestore(&gpio_lock, flags);
err_free_label:
        kfree(gdev->label);
err_free_descs:
        kfree(gdev->descs);
err_free_gdev:
        ida_simple_remove(&gpio_ida, gdev->id);
        /* failures here can mean systems won't boot... */
        pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
               gdev->base, gdev->base + gdev->ngpio - 1,
               chip->label ? : "generic");
        kfree(gdev);
        return status;
}
EXPORT_SYMBOL_GPL(gpiochip_add_data);

 

gpiochip_get_desc()

drivers/gpio/gpiolib.c

/**
 * gpiochip_get_desc - get the GPIO descriptor corresponding to the given
 *                     hardware number for this chip
 * @chip: GPIO chip
 * @hwnum: hardware number of the GPIO for this chip
 *
 * Returns:
 * A pointer to the GPIO descriptor or %ERR_PTR(-EINVAL) if no GPIO exists
 * in the given chip for the specified hardware number.
 */
struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
                                    u16 hwnum)
{
        struct gpio_device *gdev = chip->gpiodev;

        if (hwnum >= gdev->ngpio)
                return ERR_PTR(-EINVAL);

        return &gdev->descs[hwnum];
}

인자로 전달받은 gpiochip에 있는 gpio 디스크립터 배열에서 hwnum 인덱스 위치의 gpio 디스크립터를 반환한다.

 

gpiochip_setup_dev()

drivers/gpio/gpiolib.c

static int gpiochip_setup_dev(struct gpio_device *gdev)
{
        int status;

        cdev_init(&gdev->chrdev, &gpio_fileops);
        gdev->chrdev.owner = THIS_MODULE;
        gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);

        status = cdev_device_add(&gdev->chrdev, &gdev->dev);
        if (status)
                return status;

        chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
                 MAJOR(gpio_devt), gdev->id);

        status = gpiochip_sysfs_register(gdev);
        if (status)
                goto err_remove_device;

        /* From this point, the .release() function cleans up gpio_device */
        gdev->dev.release = gpiodevice_release;
        pr_debug("%s: registered GPIOs %d to %d on device: %s (%s)\n",
                 __func__, gdev->base, gdev->base + gdev->ngpio - 1,
                 dev_name(&gdev->dev), gdev->chip->label ? : "generic");

        return 0;

err_remove_device:
        cdev_device_del(&gdev->chrdev, &gdev->dev);
        return status;
}

gpiochip을 캐릭터 디바이스로 등록하고 sysfs bus에 노출시킨다.

 

gpio 디바이스 관리

gpio 디바이스의 gpio 번호 대역을 관리하기 위한 방법이 있다.

  • gpio 디바이스마다 gpio 번호 대역이 있다. 시작 번호에 해당하는 base와 개수에 해당하는 ngpio이다.
  • gpio 디바이스에서 사용하는 gpio 번호 대역은 가능하면 가장 우측부터 사용된다.

 

gpiochip_find_base()

drivers/gpio/gpiolib.c

/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
static int gpiochip_find_base(int ngpio)
{
        struct gpio_device *gdev;
        int base = ARCH_NR_GPIOS - ngpio;

        list_for_each_entry_reverse(gdev, &gpio_devices, list) {
                /* found a free space? */
                if (gdev->base + gdev->ngpio <= base)
                        break;
                else
                        /* nope, check the space right before the chip */
                        base = gdev->base - ngpio;
        }

        if (gpio_is_valid(base)) {
                pr_debug("%s: found new base at %d\n", __func__, base);
                return base;
        } else {
                pr_err("%s: cannot find free range\n", __func__);
                return -ENOSPC;
        }
}

아키텍처 지원 gpio 최대 개수가 사용할 수 있는 최대 범위(512 또는 벤더가 지정한 값)내에서 gpio 디바이스들이 사용하지 않는 gpio 번호 대역을 피해 가장 우측 번호에 들어갈 수 있는 시작 번호를 반환한다.

  • 코드 라인 5에서 사용할 수 있는 gpio 시작 번호를 찾기 위해 base 값에 아키텍처 지원 gpio 최대 개수에서 인자로 전달받은 ngpio 수 만큼 뺀다.
    • 아키텍처 지원 gpio 최대 개수는 특별히 지정되지 않은 경우 512개를 사용한다.
  • 코드 라인 7~14에서 전역 gpio 디바이스 리스트에서 gpio 디바이스를 순회하며 순회 중인 gpio 디바이스가 사용하는 gpio 범위가  base보다 작은 경우 즉, 우측에 공간이 있는 경우 루프를 벗어나서 그 base 값으로 함수를 빠져나간다. 그렇지 않은 경우 순회 중인 디바이스가 사용하는 base 번호에서 ngpio 수만큼 빼고 계속 순회한다.
    • 예) gpio 디바이스가 440~472까지 32개의 gpio를 사용 중에 추가로 ngpio=32개 요청한 경우 -> base 값은 480이다.
    • 예) gpio 디바이스가 450~482까지 32개의 gpio를 사용 중에 추가로 ngpio=32개 요청한 경우 -> base 값은 418이다.
    • 예) 등록된 gpio 디바이스가 없는 상태에서 처음 32개를 요구하면 반환되는 base 값은 512 – 32 = 480이다.

 

gpiodev_add_to_list()

gpio 디바이스를 전역 gpio 디바이스 리스트에 추가할 때 base 번호 순으로 정렬되도록 끼워 넣는다.

drivers/gpio/gpiolib.c

/*
 * Add a new chip to the global chips list, keeping the list of chips sorted
 * by range(means [base, base + ngpio - 1]) order.
 *
 * Return -EBUSY if the new chip overlaps with some other chip's integer
 * space.
 */
static int gpiodev_add_to_list(struct gpio_device *gdev)
{
        struct gpio_device *prev, *next;

        if (list_empty(&gpio_devices)) {
                /* initial entry in list */
                list_add_tail(&gdev->list, &gpio_devices);
                return 0;
        }

        next = list_entry(gpio_devices.next, struct gpio_device, list);
        if (gdev->base + gdev->ngpio <= next->base) {
                /* add before first entry */
                list_add(&gdev->list, &gpio_devices);
                return 0;
        }

        prev = list_entry(gpio_devices.prev, struct gpio_device, list);
        if (prev->base + prev->ngpio <= gdev->base) {
                /* add behind last entry */
                list_add_tail(&gdev->list, &gpio_devices);
                return 0;
        }

        list_for_each_entry_safe(prev, next, &gpio_devices, list) {
                /* at the end of the list */
                if (&next->list == &gpio_devices)
                        break;

                /* add between prev and next */
                if (prev->base + prev->ngpio <= gdev->base
                                && gdev->base + gdev->ngpio <= next->base) {
                        list_add(&gdev->list, &prev->list);
                        return 0;
                }
        }

        dev_err(&gdev->dev, "GPIO integer space overlap, cannot add chip\n");
        return -EBUSY;
}

 

GPIO 오퍼레이션

각 벤더들은 GPIO controller 디바이스 드라이버를 작성하기 위해 gpio controller에 대한 operation 함수를 작성하여야 한다.

  • gpio operation에 대한 항목들은 아래 그림에서 좌측 후크 함수들이 있는 곳에 해당한다.
  • 추가로 IRQ 처리가 필요한 경우 irq chain 연결이 필요하다 이에 대한 구현은 다음과 같다.
    • 첫 번째, gpio controller 디바이스 드라이버의 시작 지점인 probe 함수에서 gpio용 irq controller의 operation 을 구성해야 한다. 따라서 irq_chip을 구성하고 gpio_chip_irqchip_add() 함수를 사용하여 등록한다.
    • 두 번째 gpiochip_set_chained_irqchip() 함수를 사용하여 상위 IRQ controller와 연동해야 한다. 연동 시 상위에 연결한 parent irq 번호를 알고 있어야 한다.

include/linux/gpio/driver.h

struct gpio_chip {
        ...
        int     (*request)(struct gpio_chip *chip, unsigned offset);
        void    (*free)(struct gpio_chip *chip, unsigned offset);
        int     (*get_direction)(struct gpio_chip *chip, unsigned offset);
        int     (*direction_input)(struct gpio_chip *chip, unsigned offset);
        int     (*direction_output)(struct gpio_chip *chip, unsigned offset, int value);
        int     (*get)(struct gpio_chip *chip, unsigned offset);
        void    (*set)(struct gpio_chip *chip, unsigned offset, int value);
        void    (*set_multiple)(struct gpio_chip *chip, unsigned long *mask, unsigned long *bits);
        int     (*set_config)(struct gpio_chip *chip, unsigned offset, unsigned long config); 
        int     (*to_irq)(struct gpio_chip *chip, unsigned offset);
        void    (*dbg_show)(struct seq_file *s, struct gpio_chip *chip);
        ...
}
  • (*request)
    • pin과 관련하여 HW에 먼저 activation 설정이 필요한 경우에 구현한다.
      • gpio 핀의 사용을 위해 먼저 파워 설정이나 sleep 관련 등의 HW 설정이 필요한 경우이다.
    • pin controller와 연동된 경우 pinmux를 통해 gpio를 먼저 선택하게 요청한다.
      • 해당 gpio 핀이 항상 gpio function으로 고정된 경우 이 후크는 구현할 필요 없다.
  • (*free)
    • 위 (*request) 후크에서 설정한 것을 deactivation이 필요한 경우에 구현한다.
  • (*get_direction)
    • offset에 해당하는 gpio 핀이 입력(0) 모드인지 출력(0) 모드인지 HW로부터 알아온다.
  • (*direction_input)
    • offset에 해당하는 gpio 핀을 input 모드로 HW 설정한다.
  • (*direction_output)
    • gpio 핀을 output 모드로 HW 설정하고 출력 값을 기록한다.
  • (*get)
    • gpio 핀에 대한 시그널(high=1, low=0, 에러=-1) 값을 읽어온다. (보통 input 모드에서 사용)
  • (set)
    • gpio 핀에 대한 시그널 값을 기록한다. (보통 output 모드에서 사용)
  • (*set_multiple)
    • 여러 개의 gpio 핀들에 대한 값을 기록한다. 단 mask에 해당하는 핀들만 기록한다. (보통 output 모드에서 사용)
  • (*set_config)
    • offset에 해당하는 gpio 핀에 대한 각종 HW 설정이 필요한 경우 구현한다.
    • pin controller의 pinconf와 연동되어 사용하는 경우가 많다.
  • (*to_irq)
    • offset에 해당하는 gpio 핀이 어떠한 irq로 매핑되어 있는지 알아와야 할 필요가 있을 때 구현한다.
    • 정적(static) 매핑을 사용하지 않고 동적(dynamic) 매핑을 사용하는 경우 구현한다.
    • 예) 절전 모드에서 매핑이 변경되는 구성
  • (*dbg_show)
    • debugfs를 통해 출력하고 싶은 내용이 있는 경우 구현한다.
    • 예) pullup/pulldown 설정 상태

 

broadcom ns2 소스 예

iproc_gpio_request()

drivers/pinctrl/bcm/pinctrl-iproc-gpio.c

/*
 * Request the Iproc IOMUX pinmux controller to mux individual pins to GPIO
 */
static int iproc_gpio_request(struct gpio_chip *gc, unsigned offset)
{
        struct iproc_gpio *chip = gpiochip_get_data(gc);
        unsigned gpio = gc->base + offset;

        /* not all Iproc GPIO pins can be muxed individually */
        if (!chip->pinmux_is_supported)
                return 0;

        return pinctrl_request_gpio(gpio);
}

offset에 해당하는 gpio 핀을 pin controller의 pinmux를 통해 선택한다

  • pinmux_is_supported
    • gpio controller 노드에서 “gpio-ranges” 속성을 사용하여 pin controller와 연동된 경우 설정된다.

 

iproc_gpio_direction_input()

drivers/pinctrl/bcm/pinctrl-iproc-gpio.c

static int iproc_gpio_direction_input(struct gpio_chip *gc, unsigned gpio)
{
        struct iproc_gpio *chip = gpiochip_get_data(gc);
        unsigned long flags;

        raw_spin_lock_irqsave(&chip->lock, flags);
        iproc_set_bit(chip, IPROC_GPIO_OUT_EN_OFFSET, gpio, false);
        raw_spin_unlock_irqrestore(&chip->lock, flags);

        dev_dbg(chip->dev, "gpio:%u set input\n", gpio);

        return 0;
}

gpio 레지스터를 통해 gpio 번호에 해당하는 gpio 핀을 input 모드로 설정한다.

 

iproc_gpio_set()

drivers/pinctrl/bcm/pinctrl-iproc-gpio.c

static void iproc_gpio_set(struct gpio_chip *gc, unsigned gpio, int val)
{
        struct iproc_gpio *chip = gpiochip_get_data(gc);
        unsigned long flags;

        raw_spin_lock_irqsave(&chip->lock, flags);
        iproc_set_bit(chip, IPROC_GPIO_DATA_OUT_OFFSET, gpio, !!(val));
        raw_spin_unlock_irqrestore(&chip->lock, flags);

        dev_dbg(chip->dev, "gpio:%u set, value:%d\n", gpio, val);
}

gpio 레지스터를 읽어와서 gpio 번호에 해당하는 비트만을 val 값으로 변경하여 gpio 레지스터에 기록한다.

  • gpio 번호는 0~31번까지 사용 가능

 

iproc_set_bit()

drivers/pinctrl/bcm/pinctrl-iproc-gpio.c

/**
 *  iproc_set_bit - set or clear one bit (corresponding to the GPIO pin) in a
 *  Iproc GPIO register
 *
 *  @iproc_gpio: Iproc GPIO device
 *  @reg: register offset
 *  @gpio: GPIO pin
 *  @set: set or clear
 */
static inline void iproc_set_bit(struct iproc_gpio *chip, unsigned int reg,
                                  unsigned gpio, bool set)
{
        unsigned int offset = IPROC_GPIO_REG(gpio, reg);
        unsigned int shift = IPROC_GPIO_SHIFT(gpio);
        u32 val;

        val = readl(chip->base + offset);
        if (set)
                val |= BIT(shift);
        else
                val &= ~BIT(shift);
        writel(val, chip->base + offset);
}

gpio 레지스터를 읽어와서 gpio 번호에 해당하는 비트만을 변경하여 다시 gpio 레지스터에 기록한다.

  • gpio 번호는 0~31번까지 사용 가능

 

iproc_gpio_get()

drivers/pinctrl/bcm/pinctrl-iproc-gpio.c

static int iproc_gpio_get(struct gpio_chip *gc, unsigned gpio)
{
        struct iproc_gpio *chip = gpiochip_get_data(gc);
        unsigned int offset = IPROC_GPIO_REG(gpio,
                                              IPROC_GPIO_DATA_IN_OFFSET);
        unsigned int shift = IPROC_GPIO_SHIFT(gpio);

        return !!(readl(chip->base + offset) & BIT(shift));
}

gpio 레지스터를 읽어와서 gpio 번호에 해당하는 비트 값을 반환한다. (low=0, high=1)

  • gpio 번호는 0~31번까지 사용 가능

 

gpio 디스크립터에 연결된 irq 번호 얻기

gpiod_to_irq()

drivers/gpio/gpiolib.c

/**
 * gpiod_to_irq() - return the IRQ corresponding to a GPIO
 * @desc: gpio whose IRQ will be returned (already requested)
 *
 * Return the IRQ corresponding to the passed GPIO, or an error code in case of
 * error.
 */
int gpiod_to_irq(const struct gpio_desc *desc)
{
        struct gpio_chip *chip;
        int offset;

        /*
         * Cannot VALIDATE_DESC() here as gpiod_to_irq() consumer semantics
         * requires this function to not return zero on an invalid descriptor
         * but rather a negative error number.
         */
        if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
                return -EINVAL;

        chip = desc->gdev->chip;
        offset = gpio_chip_hwgpio(desc);
        if (chip->to_irq) {
                int retirq = chip->to_irq(chip, offset);

                /* Zero means NO_IRQ */
                if (!retirq)
                        return -ENXIO;

                return retirq;
        }
        return -ENXIO;
}
EXPORT_SYMBOL_GPL(gpiod_to_irq);

인자로 주어진 gpio 디스크립터에 해당하는 gpio 핀에 연결된 irq 번호를 알아온다.

  • gpio 디스크립터에 해당하는 gpiochip이 없으면 -EINVAL 에러를 반환한다.
  • 연결된 irq가 없는 경우 -ENXIO 에러를 반환한다.

 

상위 Interrupt 컨트롤러와의 Cascade 연동

인터럽트 컨트롤러간 Cascade 연동에는 다음 두 가지 방법 중 하나를 사용해야 한다.

  • chained irq
    • 인터럽트 핸들러가 irq context에서 동작한다.
    • 인터럽트 핸들러에서 하위 장치(gpio) 레지스터를 호출할 때 느린 api를 사용하면 안된다. (blocking api 금지)
    • SoC 내부에 연결된 gpio를 연결할 때 사용된다.
    • PCI  버스뒤에 연결된 gpio도 사용할 수 있다. (pci는 빠르므로)
  • nested irq
    • 인터럽트 핸들러가 process context에서 동작한다. 즉 RT 스레드가 wakeup 된다.
    • 인터럽트 핸들러에서 하위 장치(gpio) 레지스터를 호출할 때 느린 api를 사용할 수 있다.
    • 주로 i2c 나 spi 버스 뒤에 gpio 같은 장치가 연결되어 사용할 때 사용한다.

 

다음 그림은 gpio controller 디바이스 드라이버의 초입인 probe 함수에서 chained irq 연계를 위한 함수 호출 과정을 보여준다.

 

gpio contoller에서 등록할 irq_chip에 연계되는 구조체들의 연결을 보여준다.

  • irq 연결에 대한 로지컬 다이어그램은 아래 그림의 좌측 하단을 참고한다.

 

gpiochip용 irq 도메인 오퍼레이션

gpiochip용 irq 도메인 오퍼레이션은 전역에 선언된 &gpiochip_domain_ops를 사용하며 다음 후크 함수들이 고정되어 사용된다.

static const struct irq_domain_ops gpiochip_domain_ops = {
        .map    = gpiochip_irq_map,
        .unmap  = gpiochip_irq_unmap,
        /* Virtually all GPIO irqchips are twocell:ed */
        .xlate  = irq_domain_xlate_twocell,
};
  • gpiochip_irq_map()
    • gpiochip에 주어진 irqchip과 irq 핸들러 함수를 해당 irq 디스크립터에 설정한다.
  • gpiochip_irq_unmap()
    • irq 디스크립터에 설정해둔 irqchip과 irq 핸들러 함수를 null을 대입하여 클리어한다.
  • irq_domain_xlate_twocell()
    • 첫 번째 argument를 변환 없이 그대로 hwirq로 사용
    • 두 번째 argument를 변환 없이 그대로 타입으로 사용

 

gpio_chip과 irq_chip을 한꺼번에 처리할 수 있는 gpio_irq_chip 구조체와  gpiochip_add_irqchip() 함수도 커널 v4.15-rc1에 소개되었다.

 

gpiochip_irqchip_add()

include/linux/gpio/driver.h

static inline int gpiochip_irqchip_add(struct gpio_chip *gpiochip,
                       struct irq_chip *irqchip,
                       unsigned int first_irq,
                       irq_flow_handler_t handler,
                       unsigned int type)
{
    return gpiochip_irqchip_add_key(gpiochip, irqchip, first_irq,
                    handler, type, false, NULL);
}

gpio에서 사용하는 irq에 대한 컨트롤을 위해 gpiochip에 irqchip을 추가한다.

 

gpiochip_irqchip_add_key()

gpio에서 사용하는 irq에 대한 컨트롤을 위해 gpiochip에 irqchip을 추가한다.

  • 네 번째 인자로 전달받은 handler 함수는 종종 미리 정의된 irq core 함수를 사용한다. 대부분 아래 네 가지 중 하나를 사용한다.
    • handle_edge_irq()
    • handle_level_irq()
    • handle_simple_irq() – common case
    • handle_bad_irq()
  • 다섯 번째 인자로 전달받은 타입으로 irqchip의 타입이 설정된다.
    • 대부분 IRQ_TYPE_NONE 값을 사용하고, 이러한 경우 어떠한 값도 HW에 설정하지 않는다.
  • 여섯 번째 인자는 handle_nested_irq() 함수에서 호출된 경우 true를 받는다.
  • 일곱 번째 인자는 lockdep을 사용하는 경우에만 전달되며, 사용하지 않는 경우 null을 받는다.

drivers/gpio/gpiolib.c

/**
 * gpiochip_irqchip_add_key() - adds an irqchip to a gpiochip
 * @gpiochip: the gpiochip to add the irqchip to
 * @irqchip: the irqchip to add to the gpiochip
 * @first_irq: if not dynamically assigned, the base (first) IRQ to
 * allocate gpiochip irqs from
 * @handler: the irq handler to use (often a predefined irq core function)
 * @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE
 * to have the core avoid setting up any default type in the hardware.
 * @nested: whether this is a nested irqchip calling handle_nested_irq()
 * in its IRQ handler
 * @lock_key: lockdep class
 *
 * This function closely associates a certain irqchip with a certain
 * gpiochip, providing an irq domain to translate the local IRQs to
 * global irqs in the gpiolib core, and making sure that the gpiochip
 * is passed as chip data to all related functions. Driver callbacks
 * need to use gpiochip_get_data() to get their local state containers back
 * from the gpiochip passed as chip data. An irqdomain will be stored
 * in the gpiochip that shall be used by the driver to handle IRQ number
 * translation. The gpiochip will need to be initialized and registered
 * before calling this function.
 *
 * This function will handle two cell:ed simple IRQs and assumes all
 * the pins on the gpiochip can generate a unique IRQ. Everything else
 * need to be open coded.
 */
int gpiochip_irqchip_add_key(struct gpio_chip *gpiochip,
                 struct irq_chip *irqchip,
                 unsigned int first_irq,
                 irq_flow_handler_t handler,
                 unsigned int type,
                 bool nested,
                 struct lock_class_key *lock_key)
{
    struct device_node *of_node;

    if (!gpiochip || !irqchip)
        return -EINVAL;

    if (!gpiochip->parent) {
        pr_err("missing gpiochip .dev parent pointer\n");
        return -EINVAL;
    }
    gpiochip->irq_nested = nested;
    of_node = gpiochip->parent->of_node;
#ifdef CONFIG_OF_GPIO
    /*
     * If the gpiochip has an assigned OF node this takes precedence
     * FIXME: get rid of this and use gpiochip->parent->of_node
     * everywhere
     */
    if (gpiochip->of_node)
        of_node = gpiochip->of_node;
#endif
  • 코드 라인 38~39에서 gpiochip 및 irqchip을 전달 받지 못한 경우 에러로 함수를 빠져나간다.
  • 코드 라인 41~44에서 gpiochip이 연결되어 있는 상위 디바이스가 지정되지 않은 경우 에러 메시지를 출력하고 함수를 빠져나간다.
    • 상위 디바이스는 i2c,  usb, pci 버스 또는 플랫폼 디바이스이다.
  • 코드 라인 46~55에서 gpiochip에 해당하는 디바이스 트리 노드를 읽어온 경우 of_node에 대입한다. 그렇지 않은 경우는 부모 버스 디바이스노드를 of_node에 대입한다.

 

    /*
     * Specifying a default trigger is a terrible idea if DT or ACPI is
     * used to configure the interrupts, as you may end-up with
     * conflicting triggers. Tell the user, and reset to NONE.
     */
    if (WARN(of_node && type != IRQ_TYPE_NONE,
         "%pOF: Ignoring %d default trigger\n", of_node, type))
        type = IRQ_TYPE_NONE;
    if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
        acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
                 "Ignoring %d default trigger\n", type);
        type = IRQ_TYPE_NONE;
    }

    gpiochip->irqchip = irqchip;
    gpiochip->irq_handler = handler;
    gpiochip->irq_default_type = type;
    gpiochip->to_irq = gpiochip_to_irq;
    gpiochip->lock_key = lock_key;
    gpiochip->irqdomain = irq_domain_add_simple(of_node,
                    gpiochip->ngpio, first_irq,
                    &gpiochip_domain_ops, gpiochip);
    if (!gpiochip->irqdomain) {
        gpiochip->irqchip = NULL;
        return -EINVAL;
    }

    /*
     * It is possible for a driver to override this, but only if the
     * alternative functions are both implemented.
     */
    if (!irqchip->irq_request_resources &&
        !irqchip->irq_release_resources) {
        irqchip->irq_request_resources = gpiochip_irq_reqres;
        irqchip->irq_release_resources = gpiochip_irq_relres;
    }

    acpi_gpiochip_request_interrupts(gpiochip);

    return 0;
}
EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_key);
  • 코드 라인 6~8에서 디바이스 트리 노드가 있으면서 IRQ_TYPE_NONE 타입을 사용하지 않은 경우 경고 메시지를 출력하고 IRQ_TYPE_NONE을 강제 지정한다.
  • 코드 라인 9~13에서 버스 디바이스가 ACPI를 지원하고 IRQ_TYPE_NONE 타입이 아닌 경우 역시 경고 메시지를 출력하고 IRQ_TYPE_NONE을 강제 지정한다.
  • 코드 라인 15~19에서 gpiochip의 멤버들을 설정하되 (*to_irq) 후크에는 gpiochip_to_irq() 함수를 대입한다.
  • 코드 라인 20~26에서 simple 방식으로 gpio 핀 개수만큼 irq_domain을 생성한다. irq_domain용 오퍼레이션은 전역에 고정 선언된 &gpiochip_domain_ops를 사용한다.
  • 코드 라인 32~36에서 인자로 전달받은 irqchip의 두 후크 (*irq_request_resources) 및 (*irq_release_resources) 둘 다 설정되어 있지 않으면 각각  gpiochip_irq_reqres() 함수와 gpiochip_irq_reqres() 함수를 대입하여 사용한다.
    • gpiochip_irq_reqres()
      • gpio 디스크립터를 반환해오되 인터럽트와 연결되었음을 알리는 gpio 플래그를 설정하고 label 명으로 “interrupt”를 사용한다.
    • gpiochip_irq_relres()
      • gpio 디스크립터의 플래그에서 인터럽트와 연결되었음을 알리는 플래그를 클리어하고, label 명에 null을 대입하여 클리언한다.
  • 코드 라인 38에서 ACPI가 지원되는 경우 gpiochip에 대한 ACPI 이벤트를 위해 isr을 등록한다.

 

gpiochip_set_chained_irqchip()

chained 방식 interrupt 처리가 가능한 gpio controller를 위해 irq 및 irq 핸들러가 등록되었을 때, 인터럽트가 발생 시 처리되는 모습을 보여준다.

  • 먼저 interrupt controller의 ISR을 통해 발생한 인터럽트 400번 디스크립터를 찾는다.
  • 400번 디스크립터에 등록된 핸들러 함수 foo_gpio_irq_handler() 함수를 호출한다.
  • foo_gpio_irq_handler() 함수는 인터럽트가 설정된 gpio 핀들을 검사하여 인터럽트가 발생한 gpio 핀을 찾아 해당 child irq 번호를 찾는다.
  • 찾은 child irq에 해당하는 irq 디스크립터에 있는 irq subsystem core가 제공하는  generic 함수인 handle_simple_irq()를 호출한다.
  • handle_simple_irq() 함수는 custom 디바이스의 인터럽트 핸들러 루틴을 찾아 호출한다.
    • Custom 디바이스의 인터럽트 핸들러 등록은 다음 함수들을 사용한다.
      • request_irq() & devm_request_irq()
      • request_threaded_irq() & devm_request_threaded_irq()
      • request_any_context_irq() & devm_request_any_context_irq()
      • request_percpu_irq()

 

아래 그림은 cascaded irq 처리를 chained irq 방식으로 처리하고 있는 모습을 보여준다.

  • irq12번과 irq21번에 연결된 핸들러들이 irq context에서 처리되는 것을 알 수 있다.

drivers/gpio/gpiolib.c

/**                          
 * gpiochip_set_chained_irqchip() - connects a chained irqchip to a gpiochip
 * @gpiochip: the gpiochip to set the irqchip chain to
 * @irqchip: the irqchip to chain to the gpiochip
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * chained irqchip     
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
 */ 
void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
                  struct irq_chip *irqchip,
                  unsigned int parent_irq,
                  irq_flow_handler_t parent_handler)
{       
    gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
                      parent_handler);
}      
EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);

chain된 irqchip을 gpiochip에 연결시킨다. 상위 인터럽트 컨트롤러에 연결될 parent_irq 번호와  이에 해당하는 핸들러도 같이 주어진다.

 

gpiochip_set_nested_irqchip()

아래 그림과 같이 cascaded interrupt 처리를 nested irq 방식으로 처리한 모습을 보여준다.

  • irq12번의 인터럽트 핸들러는 irq context에서 처리되지만, irq21번의 인터럽트 핸들러는 process context에서 처리되는 것을 알 수 있다.

 

drivers/gpio/gpiolib.c

/**
 * gpiochip_set_nested_irqchip() - connects a nested irqchip to a gpiochip
 * @gpiochip: the gpiochip to set the irqchip nested handler to
 * @irqchip: the irqchip to nest to the gpiochip
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * nested irqchip
 */
void gpiochip_set_nested_irqchip(struct gpio_chip *gpiochip,
                                 struct irq_chip *irqchip,
                                 unsigned int parent_irq)
{
        if (!gpiochip->irq_nested) {
                chip_err(gpiochip, "tried to nest a chained gpiochip\n");
                return;
        }
        gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
                                      NULL);
}
EXPORT_SYMBOL_GPL(gpiochip_set_nested_irqchip);

 

 

gpiochip_set_cascaded_irqchip()

drivers/gpio/gpiolib.c

/**
 * gpiochip_set_cascaded_irqchip() - connects a cascaded irqchip to a gpiochip
 * @gpiochip: the gpiochip to set the irqchip chain to
 * @irqchip: the irqchip to chain to the gpiochip
 * @parent_irq: the irq number corresponding to the parent IRQ for this
 * chained irqchip
 * @parent_handler: the parent interrupt handler for the accumulated IRQ
 * coming out of the gpiochip. If the interrupt is nested rather than
 * cascaded, pass NULL in this handler argument
 */
static void gpiochip_set_cascaded_irqchip(struct gpio_chip *gpiochip,
                      struct irq_chip *irqchip,
                      unsigned int parent_irq,
                      irq_flow_handler_t parent_handler)
{
    unsigned int offset;

    if (!gpiochip->irqdomain) {
        chip_err(gpiochip, "called %s before setting up irqchip\n",
             __func__);
        return;
    }

    if (parent_handler) {
        if (gpiochip->can_sleep) {
            chip_err(gpiochip,
                 "you cannot have chained interrupts on a "
                 "chip that may sleep\n");
            return;
        }
        /*             
         * The parent irqchip is already using the chip_data for this
         * irqchip, so our callbacks simply use the handler_data.
         */
        irq_set_chained_handler_and_data(parent_irq, parent_handler,
                         gpiochip);
        
        gpiochip->irq_chained_parent = parent_irq;
    }

    /* Set the parent IRQ for all affected IRQs */
    for (offset = 0; offset < gpiochip->ngpio; offset++) {
        if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
            continue;
        irq_set_parent(irq_find_mapping(gpiochip->irqdomain, offset),
                   parent_irq);
    }
}

chained irq 처리를 위해 gpio 핀들에서 사용하는 모든 irq 디스크립터에 parent_irq를 설정한다.

  • 코드 라인 18~22에서 gpiochip에 irqdomain이 설정되지 않은 경우 에러 메시지를 출력하고 함수를 빠져나간다.
  • 코드 라인 24~39에서 chain된 parent_irq 번호와 핸들러를 등록한다. gpiochip에 sleep 기능이 있으면 인터럽트 처리를 할 수 없으므로 gpiochip 에서는 chained 인터럽트를 설정 시 에러가 발생한다.
  • 코드 라인 42~47에서 gpio 칩에서 irq를 사용하는 모든 gpio핀에 연결된 irq 디스크립터에 parent_irq를 설정한다.

 

 

Generic Memory Mapped GPIO (bgpio)

레지스터 조작 기반의 GPIO 컨트롤러를 구현하는 또 다른 방법이 있다. 대부분의 GPIO가 SoC 내부에서 메모리 매핑된 GPIO 레지스터 조작만으로 동작하므로 이를 구현하기 편리하도록 제공하고 있다. 이 방법의 특징은 다음과 같다.

  • CONFIG_GPIO_GENERIC 커널 옵션을 사용한다.
  • 메모리가 매핑되어 빠르게 조작가능하므로 cascaded irq 구현 시 chained irq 연동 방식을 사용한다.
  • gpio_chip 및 irq_chip에 대한 operation 구현에 이미 준비된 후크 함수들을 사용하므로 별도로 작성할 필요가 없다.
  • irq_domain 은 미리 구성하여 사용한다.
  • memory mapped gpio 구성에 필요한 API 들
    • bgpio_init()
    • devm_gpiochip_add_data()
  • chained irq 구성에 필요한 추가 API 들
    • irq_domain 구성 API들은 생략
    • irq_alloc_generic_chip() & devm_irq_alloc_generic_chip()
    • irq_setup_generic_chip() & devm_irq_setup_generic_chip()
      • 또는 irq_set_chip_and_handler()
    • gpiochip_set_chained_irqchip()
      • 또는 irq_set_chained_handler_and_data()
  • 참고: Using gpio-generic and irq_chip_generic subsystems for gpio driver | Maquefel’s Stash

 

참고