Pin Control Subsystem -2-

Pin Control 관련 디바이스 트리

최근에는 디바이스 드라이버 내부 코드에서 매핑을 미리 선언하여 준비해두지 않고, 디바이스 트리를 통해 pinmux/pinconf 매핑을 간단히 등록할 수 있게 하였다. pinmux/pinconf 매핑을 기술하는 디바이스 트리 속성들은 각 벤더들마다 작성 방법이 약간씩 상이하지만 대체적으로 generic한 방법을 따르고 있다. 따라서 먼저 generic한 방법으로 pin control 관련 노드들을 작성하는 방법을 알아보기로 한다.

 

먼저 각 노드들을 설명하기 앞서 다음의 항목에 대해서는 그 의미를 알아야한다.

  • pinmux 매핑
    • 핀 리스트 또는 그룹 리스트에 속한 핀들 —–> Function(모드)을 매핑한다.
  • pinconf 매핑
    • 핀 리스트 또는 그릅에 속한 핀들 ——–> Configuration(bias-pull-up, …)을 매핑한다.

 

다음 그림에서 pinmux 매핑과 pinconf 매핑 두 가지 상황을 매핑하였다. 좌측에는 핀 또는 그룹명이고 우측은 pinmux 매핑에 사용하는 Function 명과 pinconf 매핑에 사용하는 Configuration 항목이다.

 

Generic Pin Controller 노드

pin controll 노드는 configuration(pinmux/pinconf) 노드들을 포함할 수 있다. 또한 추가적으로 pin controller 디바이스 드라이버가 초기화 시 Consumer 입장이 되어 pin 들의 초기화를 수행할 수 있다.

  • configuration 노드들은 다음과 같고, 아래에서 설명하는 멀티 스테이트를 사용하는 경우 configuration 노드들은 state 노드들에 포함될 수 있다.
    • pinmux 노드
    • pinconf 노드
    • Mixed pinmux/pinconf 노드
  • 스테이트 별 관리
    • 싱글 스테이트
      • configuration 노드들은 별도의 스테이트 관리를 하지 않고, 클라이언트 디바이스가 한 가지 스테이트만을 사용한다.
    • 멀티 스테이트
      • 클라이언트 디바이스가 두 가지 이상의 스테이트를 런타임에서 요청할 수 있도록 할 수 있다.
  • Consumer 입장
    • 이 노드에서 pinctrl-names 및 pinctrl-0 속성의 사용을 하는 경우이다.

 

다음 그림은 싱글 또는 멀티 스테이트에 대한 사례이다.

 

Generic pinmux 노드

아래와 같이 pinmux 노드는 여러 형태로 구성될 수 있다. pinmux 노드 밖에 state를 구분하기 위한 노드로 감쌀 수도 있다.

  • function
    • 선택할 펑션명이다.
  • groups | pins
    • 그룹 리스트 또는 핀 리스트 둘 중 하나가 지정된다.
state_0_node_a {
        uart0 {
                function = "uart0";
                groups = "u0rxtx", "u0rtscts";
        };
};
state_1_node_a {
        spi0 {
                function = "spi0";
                groups = "spi0pins";
        };
};
state_2_node_a { 
        function = "i2c0";
        pins = "mfio29", "mfio30";
};

 

생성되는 매핑 수
  • pinmux 매핑은 무조건 매핑 대상 수 만큼 만들어진다. pinmux에서 대상은 groups가 될수도 있고 pins가 될 수도 있다.
  • 따라서 위의 코드들의 매핑 수는 순서대로 2개, 1개, 2개이다.

 

Generic pinconf 노드

아래와 같이 pinconf 노드는 여러 형태로 구성될 수 있다. pinconf 노드 밖에 state를 구분하기 위한 노드로 감쌀 수도 있다.

  • pins | group | pinmux
    • 핀 리스트, 하나의 그룹, 핀먹스 셋 중 하나가 지정된다.
    • 핀 먹스가 사용되는 경우 정수 핀 id 들이 지정된다.
  • 핀에 설정할 항목들
    • bias-pull-down, bias-pull-up, input-enable, …
state_0_node_a {
        cts_rxd {
                pins = "GPIO0_AJ5", "GPIO2_AH4"; /* CTS+RXD */
                bias-pull-up;
        };
};
state_1_node_a {
        rts_txd {
                pins = "GPIO1_AJ3", "GPIO3_AH3"; /* RTS+TXD */
                output-high;
        };
};
state_2_node_a {
        foo {
                group = "foo-group";
                bias-pull-up;
        };
};
state_3_node_a {
        mux {
                pinmux = <GPIOx_PINm_MUXn>, <GPIOx_PINj_MUXk)>;
                input-enable;
        };
};

 

생성되는 매핑 수
  • pinconf 매핑은 설정 항목의 수와는 무관하고, pinmux와 같이 무조건 매핑 대상 수 만큼 만들어진다.  pinmux에서 대상은 group, pins 또는 pinmux 로 지정된 대상 수 이다.
  • 따라서 위의 코드들의 매핑 수는 순서대로 2개, 2개, 1개, 2개이다.

 

Mixed pinmux/pinconf 노드

아래와 같이 핀들에 대해 function과 configuraton 항목이 동시에 사용되었음을 알 수 있다. pin controller H/W가 mux를 사용하면서 pin 설정을 동시에 해야 하는 경우가 있다. 이렇게 하나의 노드에서 pinmux와 pinconf 매핑이 동시에 표현되는 경우 커널 내부에서는 하나의 매핑 맵으로 처리하지 않고 pinmux 및 pinconf 매핑 맵을 각각 만들어 관리한다.

arch/arm64/boot/dts/allwinner/sun50i-a64.dtsi

.           mmc0_pins: mmc0-pins {
                pins = "PF0", "PF1", "PF2", "PF3",
                       "PF4", "PF5";
                function = "mmc0";
                drive-strength = <30>;
                bias-pull-up;
            };

 

생성되는 매핑 수

위의 디바이스 트리 노드 예에서 만들어지는 매핑 수를 알아보자.

  • pins 속성이든 groups 속성이든 해당 속성안에 있는 문자열 수를 매핑에 적용할 대상으로 판단한다.
    •  pins = “PF0”, “PF1”, “PF2”, “PF3”, “PF4”, “PF5″인 경우 대상의 수는 6개이다.
    • groups = “gpio_12_13_grp gpio_14_15_grp”인 경우 핀이 4개일지라도 대상의 수는 2개이다.
  • 위의 코드에서 pinmux 매핑은 무조건 매핑 대상 수 만큼 만들어진다. 따라서 6개이다.
  • 위의 코드에서 pinconf 매핑은 drive-strength 및 bias-pull-up 등의 설정 항목 수와 관계 없이 하나의 매핑에 포함된다. 따라서 6개이다.
  • 총 매핑 수 = 6개 매핑 대상 * (pinmux 1개 + pinconf 1개) = 12개

 

Consumer로의 사용

pin controller 디바이스 드라이버가 내부에서 Consumer 입장이 되어 pin 설정을 시도할 수도 있다. 이러한 경우 Client 디바이스에서 처럼 pinctrl-names 및 pinctrl-0 속성을 사용할 수 있다. 만일 pin controller가 초기화될 때 pin들의 초기화 설정이 필요 없으면 즉, Consumer 입장이 아니면 아래 두 속성을 지정하지 않아도 된다.

  • pinctrl-names 속성
    • pin 컨트롤러가 제공하는 state 명을 지정한다. state 구분이 필요 없는 경우 보통 “default” 스테이트 명을 사용한다.
    • 만일 N개의 스테이트명을 지정하면 아래 pinctrl-0 부터 pinctrl-N 까지의 속성을 지정해야 한다.
  • pinctrl-0 속성
    • 이 곳에는 phandle 리스트가 입력된다. 각각의 phandle은 pinmux/pinconf 노드를 가리킨다.
	pinctrl: pinctrl {
                ...
		pinctrl-names = "default";
		pinctrl-0 = <&nand_sel &uart3_rx &sdio0_d4>;
                ...
        }

위의 코드에서 pin controller 노드가 pinctrl-names에 “default”하나만 사용되었으므로 싱글 스테이트로만 사용한다. 이러한 경우 pinctrl-0 속성만을 사용한다.

 

Generic Client 노드

  • pinctrl-names 속성
    • 싱글 스테이트로 사용하는 경우 하나의 스테이트 이름만을 사용한다. 이러한 경우 보통 “default”를 사용한다.
    • 만일 N개의 스테이트명을 지정하면 아래 pinctrl-0 부터 pinctrl-N 까지의 속성을 지정해야 한다.
    • 이 속성은 생략될 수 있으며 그러한 경우 “pinctrl-” 속성 다음에 있는 숫자가 스테이트명이된다.
      • 아래 예에서 두 번째 디바이스의 경우 pinctrl-names = “0”, “1”;으로 지정한 것과 같다.
  • pinctrl-0 ~ pinctrl-N 속성
    • 이 곳에는 phandle 리스트가 입력된다. phandle 각각은 반드시 pin 컨트롤러 노드에 포함된 pinmux/pinconf 노드를 가리켜야 한다.
    • 각 스테이트는 pinctrl-0번부터 시작하여 스테이트 수 만큼 pinctrl-N 까지 순서대로 등록할 수 있다.
    • 이 스테이트 속성값이 블랭크인 경우 state 명에 빈 dummy 매핑만 등록된다.
.       /* For a client device requiring named states */
        device {
                pinctrl-names = "active", "idle";
                pinctrl-0 = <&state_0_node_a>;
                pinctrl-1 = <&state_1_node_a &state_1_node_b>;
        };

        /* For the same device if using state IDs */
        device {
                pinctrl-0 = <&state_0_node_a>;
                pinctrl-1 = <&state_1_node_a &state_1_node_b>;
        };

        /*
         * For an IP block whose binding supports pin configuration,
         * but in use on an SoC that doesn't have any pin control hardware
         */
        device {
                pinctrl-names = "active", "idle";
                pinctrl-0 = <>;
                pinctrl-1 = <>;
        };

 

Broadcom ns2 디바이스 트리 사용 예

ns2 pin controller H/W는 pinmux를 사용할 수 있는 핀들이 있고, pinconf 를 설정할 수 있는 핀들이 분류되어 있다. 따라서 ns2 pin controller 드라이버는 해당 핀들을 그룹으로 묶어서 매치 시킬 수 있는 항목들이 제한되어 있다. 다음 그림을 보고 좌측에 있는 그룹에 소속한 핀들이 우측 Function 또는 Configuration 항목과 매치 가능한 것을 알 수 있다.

 

아래 그림에서 사용한 속성과 노드들에 대해 간단히 설명을 하였다.

  • pinctrl-names 속성
    • “default” 스테이트 명 하나만을 사용하였다.
  • pinctrl-0 속성
    • “default” 스테이트 하나만을 사용하였으므로 state id는 0번만을 사용한다. 이 스테이트에는 3개의 pinmux 노드와 1개의 pinconf 노드를 가리키는 phandle을 사용하였다.
  • nand_sel pinmux 노드
    • “nand” 펑션명으로 “nand_grp” 그룹명을 매치시키는 pinmux 매핑이다.
    • 추후 이 pinmux 매핑이 선택되면 “nand_grp”에 속한 많은 핀들이 “nand” 펑션명으로 설정된다.
  • uart0_sel pinmux 노드
    • “uart0” 펑션명으로 3개의 그룹을 매치시키는 pinmux 매핑이다.
    • 추후 이 pinmux 매핑이 선택되면 “uart0_rts_cts_grp” 그룹명에 속한 2개의 핀, “uart0_in_out_grp” 그룹명에 속한 2개의 핀과 “uart0_modem_grp” 그룹명에 속한 4개의 핀들이 “uart0” 펑션으로 설정된다.
  • gpio_sel pinmux 노드
    • “gpio” 펑션명으로 “gpio_0_1_grp” 그룹명을 매치시키는 pinmux 매핑이다.
    • 추후 이 pinmux 매핑이 선택되면 “gpio_0_1_grp” 그룹명에 속한 2개의 핀이 “gpio” 펑션명으로 설정된다.
  • uart3_rx pinconf 노드
    • “uart3_sin” 핀명에 속한 핀을 bias-pull-up 매치시키는 pinconf 매핑이다.
    • 추후 이 pinconf 매핑이 선택되면 “uart3_sin” 핀의 bias를 pull up 시킨다.
  • uart0 클라이언트 노드
    • pinctrl-0 속성
      • 0번 state의 pinmux인 uart0_sel을 통해 3개의 그룹에 속한 핀들을 uart0 펑션으로 변경한다.
  • uart3 클라이언트 노드
    • pinctrl-0 속성
      • 0번 state의 pinconf인 uart3_rx을 통해 uart3_sin 그룹에 속한 핀의 bias를 pull-up으로 설정한다.

 

디바이스 트리내에서 핀 컨트롤러 노드와 서브 노드에 정의한 4개의 pinmux/pinconf 노드 및 2 개의 클라이언트 노드를 살펴본다.

arch/arm64/boot/dts/broadcom/northstar2/ns2-svk.dtsi

 

Pinctrl 생성 및 디바이스 트리로부터 읽어온 매핑 추가

pin controll을 사용하기 위해(Consumer의 입장) pinctrl 구조체를 생성하고 그 밑으로 디바이스 트리 매핑 맵들 및 사용하려는 스테이트들에 해당하는 각 설정들이 관리된다.

  • pinctrl 구조체 아래에 pinctrl_dt_map과 pinctrl_state 두개로 나뉘어 관리하는 모습을 확인하자.
  • 아래 두 개의 그림 사례와 같이 single state로만 관리될 때의 pinctrl_state 구조체의 차이를 확인하자.

 

multi state로 관리되는 pinctrl에는 pinctrl_state가 디바이스에서 사용하는 스테이트 수 만큼 복수개가 등록됨을 알 수 있다.

 

다음 그림은 여러 개의 디바이스 노드로부터 pinctrl을 생성하는 모습을 보여준다. 기본적으로 pin controller 노드도 consumer 입장에서 호출되었고, 나머지 pin control이 필요한 두 개의 클라이언트 디바이스 노드에서 각각 호출되어 사용된 사례이다.

 

create_pinctrl()

pin control을 사용해야 하는 디바이스 드라이버를 위해 전용 pinctrl을 생성한다.  생성된 pinctrl 구조체 는 크게 다음 두 가지를 관리한다.

  • 디바이스 트리 매핑 맵
    • 디바이스가 요청하는 모든 스테이트에서 요구되는 pinmux/pinconf 노드들을 찾아 파싱한 후 pincmux/pinconf 매핑 맵으로 만들어 등록된다.
  • 스테이트별 설정
    • 디바이스가 요청하는 각각의 스테이트별로 디바이스  트리 매핑 맵으로에서 pinmux/pinconf 설정들이 등록된다.

drivers/pinctrl/core.c – 1/2

static struct pinctrl *create_pinctrl(struct device *dev,
				      struct pinctrl_dev *pctldev)
{
	struct pinctrl *p;
	const char *devname;
	struct pinctrl_maps *maps_node;
	int i;
	const struct pinctrl_map *map;
	int ret;

	/*
	 * create the state cookie holder struct pinctrl for each
	 * mapping, this is what consumers will get when requesting
	 * a pin control handle with pinctrl_get()
	 */
	p = kzalloc(sizeof(*p), GFP_KERNEL);
	if (!p)
		return ERR_PTR(-ENOMEM);
	p->dev = dev;
	INIT_LIST_HEAD(&p->states);
	INIT_LIST_HEAD(&p->dt_maps);

	ret = pinctrl_dt_to_map(p, pctldev);
	if (ret < 0) {
		kfree(p);
		return ERR_PTR(ret);
	}

	devname = dev_name(dev);
  • 코드 라인 16~19에서 첫 번째 인자로 요청한 디바이스를 위해 pinctrl 구조체를 생성하고 pinctrl에서 디바이스를 가리키게 한다.
  • 코드 라인 20~21에서 pinctrl_state 구조체들을 담을 수 있는 리스트와 pinctrl_dt_map을 담을 수 있는 리스트를 초기화한다.
  • 코드 라인 23~27에서 요청 디바이스의 디바이스 트리 노드가 발견된 경우에 한해 pinmux/pinconf 매핑들을 파싱하여 매핑 맵들로 읽어온다.
    • 읽어온 매핑 맵들은 pinctrl_maps와 pinctrl_dt_map 두 구조체에서 관리된다.
  • 코드 라인 29에서 첫 번째 인자로 요청해온 디바이스 이름을 알아온다.
    • 주의: 요청자는 보통 클라이언트 디바이스이지만 핀 컨트롤러 디바이스일 수도 있다.

 

drivers/pinctrl/core.c – 2/2

	mutex_lock(&pinctrl_maps_mutex);
	/* Iterate over the pin control maps to locate the right ones */
	for_each_maps(maps_node, i, map) {
		/* Map must be for this device */
		if (strcmp(map->dev_name, devname))
			continue;
		/*
		 * If pctldev is not null, we are claiming hog for it,
		 * that means, setting that is served by pctldev by itself.
		 *
		 * Thus we must skip map that is for this device but is served
		 * by other device.
		 */
		if (pctldev &&
		    strcmp(dev_name(pctldev->dev), map->ctrl_dev_name))
			continue;

		ret = add_setting(p, pctldev, map);
		/*
		 * At this point the adding of a setting may:
		 *
		 * - Defer, if the pinctrl device is not yet available
		 * - Fail, if the pinctrl device is not yet available,
		 *   AND the setting is a hog. We cannot defer that, since
		 *   the hog will kick in immediately after the device
		 *   is registered.
		 *
		 * If the error returned was not -EPROBE_DEFER then we
		 * accumulate the errors to see if we end up with
		 * an -EPROBE_DEFER later, as that is the worst case.
		 */
		if (ret == -EPROBE_DEFER) {
			pinctrl_free(p, false);
			mutex_unlock(&pinctrl_maps_mutex);
			return ERR_PTR(ret);
		}
	}
	mutex_unlock(&pinctrl_maps_mutex);

	if (ret < 0) {
		/* If some other error than deferral occurred, return here */
		pinctrl_free(p, false);
		return ERR_PTR(ret);
	}

	kref_init(&p->users);

	/* Add the pinctrl handle to the global list */
	mutex_lock(&pinctrl_list_mutex);
	list_add_tail(&p->node, &pinctrl_list);
	mutex_unlock(&pinctrl_list_mutex);

	return p;
}
  • 코드 라인 3에서 전역 pinctrl_maps 리스트에 등록된 pinctrl_maps 구조체들과 그 멤버 maps가 가리키는 pinctrl_map 구조체 배열을 이중 루프 순회하며 pinctrl_map 구조체를 map 변수에 알아온다.
  • 코드 라인 5~6에서 순회 중인 map의 dev_name이 요청한 디바이스와 다른 경우 skip 한다.
  • 코드 라인 14~16에서 순회 중인 map의 ctrl_dev_name이 pin controller 디바이스 명과 다른 경우도 skip 한다.
  • 코드 라인 18~36에서 매핑 설정을 추가한다. 만일 pin controller 디바이스가 아직 준비되지 않은 경우 pinctrl 이하 모두 할당 해제한다.
  • 코드 라인 40~44에서 기타 이유로 매핑 설정 추가에 실패하는 경우도 pinctrl 이하 모두 할당 해제하고 함수를 빠져나간다.
  • 코드 라인 49~51에서 에러가 없는 경우이다. 생성한 pinctrl을 전역 pinctrl_list에 추가한다.

 

디바이스 트리로부터 매핑 생성

다음 그림은 클라이언트 디바이스 노드가 요구하는 매핑 맵을 등록할 때의 함수 호출 과정이다.

  • 클라이언트 디바이스 노드로부터 요청
    • “pinctrl-names=”에 요구된 state 명 수만큼 “pinctrl-0” 부터 “pinctrl-N”에 기재된 phandle에 해당하는 노드들
  • Pin controller 디바이스 노드에서 검색
    • phandle이 가리키는 노드가 Pin controller 서브 노드 또는 그 이하 서브 노드에 있는 pinmux/pinconf 노드의 매핑들을 파싱한 후 1개 이상의 매핑 맵을 생성하여 등록한다.

 

위의 디바이스 트리에서 다음 세 번의 매핑 맵 생성을 요구 받은 경우로 예를 들었다.

  • 첫 번째는 pin controller 디바이스 드라이버로부터 전체 매핑 맵을 만든다.
  • 두 번째 uart0 디바이스 드라이버로부터 pinmux의 펑션 지정을 위해 관련 매핑 맵을 만든다.
  • 세 번째 uart3 디바이스 드라이버로 부터 pinconf 설정을 위해 관련 매핑 맵을 만든다.

 

pin controller 디바이스측만 더 자세히 자료 구조를 살펴보면 다음과 같다.

  • 6개의 매핑 맵이 구성되어 있음을 알 수 있다.
    • 5개의 pinmux 매핑 맵
    • 1개의 pinconf 매핑 맵
  • 스테이트별로 관리하지 않고 디바이스가 요구하는 매핑들이 pinctrl_dt_map에 한꺼번에 등록되어 관리된다.

 

pinctrl_dt_to_map()

요청한 디바이스 트리 노드를 읽어 관련 pinmux/pinconf 노드를 파싱한 후 pinctrl_dt_map 구조체 이하에 pinmux/pinconf 매핑 맵을 등록한다.

  • “pinctrl-names” 속성을 통해 스테이트 명을 알아온다.
  • 스테이트명의 개수 만큼 “pinctrl-0” 번 부터 시작하는 “pinctrl-N” 번까지 phandle 리스트를 읽어온다.
  • phandle에 해당하는 pinmux/pinconf  노드를 찾아 해당 설정을 매핑 맵으로 구성한다.
    • pinmux 매핑 맵은 그룹명과 펑션명의 조합이다.
      • 예) uart0_modem_grp에 속한 핀들을 uart0 펑션으로 선택한다.
    • pinconf 매핑 맵은 그룹명 또는 핀명과 설정 항목들의 조합이다. 설정 항목은 복수가 가능하며 설정 값도 포함된다.
      • 예) uart3_pin에 bias-pull-up 설정하고, drive-strength를 30으로 설정한다.

drivers/pinctrl/devicetree.c – 1/2

int pinctrl_dt_to_map(struct pinctrl *p, struct pinctrl_dev *pctldev)
{
	struct device_node *np = p->dev->of_node;
	int state, ret;
	char *propname;
	struct property *prop;
	const char *statename;
	const __be32 *list;
	int size, config;
	phandle phandle;
	struct device_node *np_config;

	/* CONFIG_OF enabled, p->dev not instantiated from DT */
	if (!np) {
		if (of_have_populated_dt())
			dev_dbg(p->dev,
				"no of_node; not parsing pinctrl DT\n");
		return 0;
	}

	/* We may store pointers to property names within the node */
	of_node_get(np);

	/* For each defined state ID */
	for (state = 0; ; state++) {
		/* Retrieve the pinctrl-* property */
		propname = kasprintf(GFP_KERNEL, "pinctrl-%d", state);
		prop = of_find_property(np, propname, &size);
		kfree(propname);
		if (!prop) {
			if (state == 0) {
				of_node_put(np);
				return -ENODEV;
			}
			break;
		}
		list = prop->value;
		size /= sizeof(*list);

		/* Determine whether pinctrl-names property names the state */
		ret = of_property_read_string_index(np, "pinctrl-names",
						    state, &statename);
		/*
		 * If not, statename is just the integer state ID. But rather
		 * than dynamically allocate it and have to free it later,
		 * just point part way into the property name for the string.
		 */
		if (ret < 0) {
			/* strlen("pinctrl-") == 8 */
			statename = prop->name + 8;
		}
  • 코드 라인 14~19에서 디바이스에 해당하는 디바이스 트리 노드가 없는 경우 그냥 함수를 빠져나간다.
  • 코드 라인 25~38에서 “pinctrl-<state>” 속성명을 찾아 phandle 리스트가 담긴 속성 값의 위치는 list에 담고, size에 phandle 개수를 담는다.
    • 예) “pinctrl-0=<&uart0 &uart3>”인 경우 list=uart0 phandle 값, size=2가 담긴다.
  • 코드 라인 41~51에서 “pinctrl-names” 속성명에서 state명을 읽어온다. 만일 발견하지 못한 경우 <state> 문자열로 사용한다.
    • 예) “pinctrl-0″인 경우 statename=”0″이 된다.

 

drivers/pinctrl/devicetree.c – 2/2

		/* For every referenced pin configuration node in it */
		for (config = 0; config < size; config++) {
			phandle = be32_to_cpup(list++);

			/* Look up the pin configuration node */
			np_config = of_find_node_by_phandle(phandle);
			if (!np_config) {
				dev_err(p->dev,
					"prop %s index %i invalid phandle\n",
					prop->name, config);
				ret = -EINVAL;
				goto err;
			}

			/* Parse the node */
			ret = dt_to_map_one_config(p, pctldev, statename,
						   np_config);
			of_node_put(np_config);
			if (ret < 0)
				goto err;
		}

		/* No entries in DT? Generate a dummy state table entry */
		if (!size) {
			ret = dt_remember_dummy_state(p, statename);
			if (ret < 0)
				goto err;
		}
	}

	return 0;

err:
	pinctrl_dt_free_maps(p);
	return ret;
}
  • 코드 라인 2~13에서 phandle 개수가 담긴 size 수 만큼 루프를 돌며 phandle을 읽어와서 해당 phandle에 해당하는 pinmux/pinconf 설정 노드를 찾아 np_config에 대입한다.
  • 코드 라인 16~21에서 디바이스 트리에서 pinmux/pinconf 설정 노드를 파싱하고 매핑 맵들을 생성한 후 다음 두 개의 자료 구조에 추가하여 관리하게 한다.
    • pinctrl_maps 구조체를 생성하고 파싱한 매핑 맵들을 추가한다.
    • pinctrl_dt_map 구조체를 생성하고 파싱한 매핑 맵들을 추가한다.
  • 코드 라인 24~28에서 phandle이 하나도 없이 비어있는 경우 매핑 맵이 비어있는 dummy용 매핑 맵 하나를 만들어 역시 위의 두개의 자료 구조를 생성하여 그 밑에 추가하여 관리하게 준비한다.
    • pinctrl 구조체 밑으로 자료 구조가 비어 문제가 될 상황을 사전에 없애기 위함이다.
    • 예) “pinctrl-0 = <>;”

 

하나의 phandle에 대응하는 pinmux/pinconf 노드 파싱 후 매핑 등록

dt_to_map_one_config()

drivers/pinctrl/devicetree.c

static int dt_to_map_one_config(struct pinctrl *p, const char *statename,
                struct device_node *np_config)
{
    struct device_node *np_pctldev;
    struct pinctrl_dev *pctldev;
    const struct pinctrl_ops *ops;
    int ret;
    struct pinctrl_map *map;
    unsigned num_maps;

    /* Find the pin controller containing np_config */
    np_pctldev = of_node_get(np_config);
    for (;;) {
        np_pctldev = of_get_next_parent(np_pctldev);
        if (!np_pctldev || of_node_is_root(np_pctldev)) {
            dev_info(p->dev, "could not find pctldev for node %s, deferring probe\n",
                np_config->full_name);
            of_node_put(np_pctldev);
            /* OK let's just assume this will appear later then */
            return -EPROBE_DEFER;
        }
        pctldev = get_pinctrl_dev_from_of_node(np_pctldev);
        if (pctldev)
            break;
        /* Do not defer probing of hogs (circular loop) */
        if (np_pctldev == p->dev->of_node) {
            of_node_put(np_pctldev);
            return -ENODEV;
        }
    }
    of_node_put(np_pctldev);

    /*
     * Call pinctrl driver to parse device tree node, and
     * generate mapping table entries
     */
    ops = pctldev->desc->pctlops;
    if (!ops->dt_node_to_map) {
        dev_err(p->dev, "pctldev %s doesn't support DT\n",
            dev_name(pctldev->dev));
        return -ENODEV;
    }
    ret = ops->dt_node_to_map(pctldev, np_config, &map, &num_maps);
    if (ret < 0)
        return ret;

    /* Stash the mapping table chunk away for later use */
    return dt_remember_or_free_map(p, statename, pctldev, map, num_maps);
}

하나의 pinmux/pinconf 설정 노드를 파싱하여 매핑 맵들을 생성한다.

  • 코드 라인 12에서 인자로 주어진 pinconf/pinmux 설정 노드가 담긴 np_config를 사용하기 위해 참조 카운터를 1 증가시킨다.
  • 코드 라인 13~29에서 인자로 주어진 pinconf/pinmux 설정 노드의 부모에 pin controller 노드가 있으므로 루프를 돌며 부모 노드 쪽에서 pinctrl 디바이스 노드를 찾는다.  그런 후 찾은 디바이스 노드에 연결된 pinctrl 디바이스를 알아와서 pctldev에 대입한다.
  • 코드 라인 30에서 인자로 주어진 pinconf/pinmux 설정 노드가 담긴 np_config의 사용이 완료되었으므로 참조 카운터를 1 감소시킨다.
  • 코드 라인 37~45에서 pin controller 드라이버에 구현된 ops 후크 함수를 호출하여 pinmux/pinconf 노드를 파싱하여 만든 매핑 맵 수 만큼 pinctrl_map 구조체들을 생성한 후 map 변수명에 담아온다.
    • ns2의 경우 generic 함수인 pinconf_generic_dt_to_map_pin() 함수를 호출한다.
  • 코드 라인 48에서 다음 두 가지 자료 구조에 위에서 파싱하여 만들어진 매핑 맵들을 추후 사용할 수 있도록 등록한다.
    • pinctrl_dt_maps 구조체를 생성한 후 pinctrl->dt_maps에 추가한다.
    • pinctl_maps 구조체를 생성한 후 전역 pinctrl_maps에 추가한다.

 

Generic pinconf 노드 파싱 및 매핑 등록

pinconf_generic_dt_node_to_map_pin()

include/linux/pinctrl/pinconf-generic.h

static inline int pinconf_generic_dt_node_to_map_pin(
        struct pinctrl_dev *pctldev, struct device_node *np_config,
        struct pinctrl_map **map, unsigned *num_maps)
{
    return pinconf_generic_dt_node_to_map(pctldev, np_config, map, num_maps,
            PIN_MAP_TYPE_CONFIGS_PIN);
}

Generic pinmux/pinconf 노드를 파싱하여 pinmux/pinconf 매핑 맵들을 생성해온다.

  • generic pinconf 노드를 파싱한 경우 대상이 그룹이라하더라도 설정 타입을 pin으로만 사용한다.

 

pinconf_generic_dt_node_to_map()

drivers/pinctrl/pinconf-generic.c

int pinconf_generic_dt_node_to_map(struct pinctrl_dev *pctldev,
        struct device_node *np_config, struct pinctrl_map **map,
        unsigned *num_maps, enum pinctrl_map_type type)
{
    unsigned reserved_maps;
    struct device_node *np;
    int ret;

    reserved_maps = 0;
    *map = NULL;
    *num_maps = 0;

    ret = pinconf_generic_dt_subnode_to_map(pctldev, np_config, map,
                        &reserved_maps, num_maps, type);
    if (ret < 0)
        goto exit;

    for_each_available_child_of_node(np_config, np) {
        ret = pinconf_generic_dt_subnode_to_map(pctldev, np, map,
                    &reserved_maps, num_maps, type);
        if (ret < 0)
            goto exit;
    }
    return 0;

exit:
    pinctrl_utils_free_map(pctldev, *map, *num_maps);
    return ret;
}
EXPORT_SYMBOL_GPL(pinconf_generic_dt_node_to_map);

generic한 pinmux/pinconf 노드를 파싱하여 pinmux/pinconf 매핑 맵들을 생성해온다. pinconf 노드에서 매핑 맵을 만들 때에는 인자로 전달받은 타입으로 매핑 맵들을 만든다. 타입에 invalid 타입이 주어진 경우 “pin” 속성이 사용된 경우 pin 타입을 사용하고, “groups” 속성을 사용한 경우 group 타입이 지정된다. pinmux 노드인 경우에는 인자로 주어진 타입과 상관 없다.

  • 코드 라인 13~16에서 인자로 전달받은 np_config 디바이스 노드를 파싱하여 매핑 맵들을 만든다.
  • 코드 라인 18~23에서 서브 노드가 있는 경우 이 함수를 재귀호출 처리한다. 이렇게 하는 경우 여러 번의 노드를 파싱하여도 최종으로 하나의 할당에 다 포함되게 하여 반환된다.

 

pinconf_generic_dt_subnode_to_map()

drivers/pinctrl/pinconf-generic.c -1/2-

int pinconf_generic_dt_subnode_to_map(struct pinctrl_dev *pctldev,
        struct device_node *np, struct pinctrl_map **map,
        unsigned *reserved_maps, unsigned *num_maps,
        enum pinctrl_map_type type)
{
    int ret;
    const char *function;
    struct device *dev = pctldev->dev;
    unsigned long *configs = NULL;
    unsigned num_configs = 0;
    unsigned reserve, strings_count;
    struct property *prop;
    const char *group;
    const char *subnode_target_type = "pins";

    ret = of_property_count_strings(np, "pins");
    if (ret < 0) {
        ret = of_property_count_strings(np, "groups");
        if (ret < 0)
            /* skip this node; may contain config child nodes */
            return 0;
        if (type == PIN_MAP_TYPE_INVALID)
            type = PIN_MAP_TYPE_CONFIGS_GROUP;
        subnode_target_type = "groups";
    } else {
        if (type == PIN_MAP_TYPE_INVALID)
            type = PIN_MAP_TYPE_CONFIGS_PIN;
    }
    strings_count = ret;

    ret = of_property_read_string(np, "function", &function);
    if (ret < 0) {
        /* EINVAL=missing, which is fine since it's optional */
        if (ret != -EINVAL)
            dev_err(dev, "%pOF: could not parse property function\n",
                np);
        function = NULL;
    }

    ret = pinconf_generic_parse_dt_config(np, pctldev, &configs,
                          &num_configs);
    if (ret < 0) {
        dev_err(dev, "%pOF: could not parse node property\n", np);
        return ret;
    }

    reserve = 0;
    if (function != NULL)
        reserve++;
    if (num_configs)
        reserve++;

    reserve *= strings_count;
  • 코드 라인 16~28에서 노드내에 “pins” 속성이 있으면 pin 설정 타입으로 지정한다. 만일 없으면 “groups” 속성을 찾아 group 설정 타입으로 지정한다. 둘 다 없는 경우 child 노드들에서 검색하도록 성공(0) 결과로 함수를 빠져나간다.
  • 코드 라인 29에서 “pins” 또는 “groups” 속성 값에 있는 항목 수를 카운터 한 값이 strings_count에 대입된다.
    • 예) pins = “mfio_13 mfio_14 mfio_15” -> strings_count = 3
  • 코드 라인 31~38에서 “function” 속성 값을 읽어온다. 옵션이므로 없을 수도 있다.
  • 코드 라인 40~45에서 pinconf 설정을 파싱하여 매핑 맵으로 등록한다. 출력 인자 num_configs에는 설정 항목 수가 반환된다.
    • bias-pull-up;  drive-strength = <30>; -> 2개의 설정 항목
  • 코드 라인 47~51에서 매핑 수 만큼 reserve 카운터를 증가시킨다.
    • pinmux 및 pinconf 항목이 둘 다 있으면 reserve 값은 최대 2가 될 수 있다.
  • 코드 라인 53에서 reserve 값에 strings_count를 곱한다.
    • 예) pins = “mfio_13 mfio_14 mfio_15”; function = “uart”;   bias-pull-up;  drive-strength = <30>;
      • 대상이 3개이고 pinmux가 있고, pinconf도 있으므로 -> reserve = 6
      • bias-pull-up 및 drive-strength 등의 설정 항목 수와 상관 없이 pinconf 매핑은 하나만 만들어진다.

 

drivers/pinctrl/pinconf-generic.c -2/2-

    ret = pinctrl_utils_reserve_map(pctldev, map, reserved_maps,
            num_maps, reserve);
    if (ret < 0)
        goto exit;

    of_property_for_each_string(np, subnode_target_type, prop, group) {
        if (function) {
            ret = pinctrl_utils_add_map_mux(pctldev, map,
                    reserved_maps, num_maps, group,
                    function);
            if (ret < 0)
                goto exit;
        }

        if (num_configs) {
            ret = pinctrl_utils_add_map_configs(pctldev, map,
                    reserved_maps, num_maps, group, configs,
                    num_configs, type);
            if (ret < 0)
                goto exit;
        }
    }
    ret = 0;

exit:
    kfree(configs);
    return ret;
}
EXPORT_SYMBOL_GPL(pinconf_generic_dt_subnode_to_map);
  • 코드 라인 1~4에서 기존 매핑 수가 reserved_maps이고, 새 매핑 수는 num_maps + 위 코드에서 산출한 reserve이다. 새 매핑 수가 기존 매핑 수보다 많은 경우 pinctrl_map 구조체를 새 매핑 수 만큼 다시 생성한다.
  • 코드 라인 6~22에서 “pins” 또는 “groups” 속성에 있는 문자열수 만큼 루프를 돌며 pinmux 매핑이 있는 경우 mux 타입 맵을 추가하고, pinconf 매핑이 있는 경우 pinconf 타입 맵을 추가한다.

 

pinconf_generic_parse_dt_config()

drivers/pinctrl/pinconf-generic.c

/**
 * pinconf_generic_parse_dt_config()
 * parse the config properties into generic pinconfig values.
 * @np: node containing the pinconfig properties
 * @configs: array with nconfigs entries containing the generic pinconf values
 *           must be freed when no longer necessary.
 * @nconfigs: umber of configurations
 */
int pinconf_generic_parse_dt_config(struct device_node *np,
                    struct pinctrl_dev *pctldev,
                    unsigned long **configs,
                    unsigned int *nconfigs)
{
    unsigned long *cfg;
    unsigned int max_cfg, ncfg = 0;
    int ret;

    if (!np)
        return -EINVAL;

    /* allocate a temporary array big enough to hold one of each option */
    max_cfg = ARRAY_SIZE(dt_params);
    if (pctldev)
        max_cfg += pctldev->desc->num_custom_params;
    cfg = kcalloc(max_cfg, sizeof(*cfg), GFP_KERNEL);
    if (!cfg)
        return -ENOMEM;

    parse_dt_cfg(np, dt_params, ARRAY_SIZE(dt_params), cfg, &ncfg);
    if (pctldev && pctldev->desc->num_custom_params &&
        pctldev->desc->custom_params)
        parse_dt_cfg(np, pctldev->desc->custom_params,
                 pctldev->desc->num_custom_params, cfg, &ncfg);

    ret = 0;

    /* no configs found at all */
    if (ncfg == 0) {
        *configs = NULL;
        *nconfigs = 0;
        goto out;
    }

    /*
     * Now limit the number of configs to the real number of
     * found properties.
     */
    *configs = kmemdup(cfg, ncfg * sizeof(unsigned long), GFP_KERNEL);
    if (!*configs) {
        ret = -ENOMEM;
        goto out;
    }

    *nconfigs = ncfg;

out:
    kfree(cfg);
    return ret;
}

pinconf 노드인 경우 configration 항목들을 파싱하여 그 수 만큼 unsigned long 타입 배열로 반환한다.

  • 코드 라인 22~27에서 필요한 최대 설정 항목 수만큼 임시 배열을 생성한다. 최대 설정 항목 수는 다음 두 항목의 합을 사용한다.
    • generic 디바이스 노드가 지원하는 설정 항목(bias, drive, …) 수
    • 해당 컨트롤러가 지원하는 custom 설정 항목 수
  • 코드 라인 29에서 generic 디바이스 노드가 지원하는 설정 항목들을 대상으로 인자로 전달받은 디바이스 노드를 파싱한다.
  • 코드 라인 30~33에서 해당 컨트롤러가 지원하는 custom 설정 항목들을 대상으로 인자로 전달받은 디바이스 노드를 파싱한다.
  • 코드 라인 38~42에서 검색된 설정 항목이 하나도 없는 경우 성공(0)으로 함수를 빠져나간다.
  • 코드 라인 48~58에서 검색된 설정 항목 수 만큼 기존 배열을 일부 복사하여 unsigned long 배열을 만들어 출력 인자 configs에 대입한다. 또한 출력 인자 nconfigs에도 검색된 설정 항목 수를 대입한다. 그런 후 처음에 임시로 만든 배열은 할당 해제한다.

 

다음 그림은 하나의 pinconf 노드를  파싱하여 출력 인자 configs에 unsigned long 타입 배열로 반환하는 모습을 보여준다.

  • 아래 예에서는 노드안에 3건의 설정을 사용하였다.
  • 파싱 항목을 검색하여 비교할 때 generic 파라메터들과 디바이스 드라이버 벤더에서 제공하는 custom 파라메터들을 대상으로 검색한다.
  • 검색된 항목을 대상으로 unsigned long 타입으로 설정을 만들 때 검색된 속성의 인덱스 번호를 우측 8비트에 사용한다. 그리고 좌측은 파라메터 속성 값이 주어지지 않은 경우에 한하여 파라메터의 멤버 default_value 값을 사용한다.

 

parse_dt_cfg()

drivers/pinctrl/pinconf-generic.c

/**
 * parse_dt_cfg() - Parse DT pinconf parameters
 * @np: DT node
 * @params: Array of describing generic parameters
 * @count:  Number of entries in @params
 * @cfg:    Array of parsed config options
 * @ncfg:   Number of entries in @cfg
 *
 * Parse the config options described in @params from @np and puts the result
 * in @cfg. @cfg does not need to be empty, entries are added beginning at
 * @ncfg. @ncfg is updated to reflect the number of entries after parsing. @cfg
 * needs to have enough memory allocated to hold all possible entries.
 */
static void parse_dt_cfg(struct device_node *np,
             const struct pinconf_generic_params *params,
             unsigned int count, unsigned long *cfg,
             unsigned int *ncfg)
{
    int i;

    for (i = 0; i < count; i++) {
        u32 val;
        int ret;
        const struct pinconf_generic_params *par = &params[i];

        ret = of_property_read_u32(np, par->property, &val);

        /* property not found */
        if (ret == -EINVAL)
            continue;

        /* use default value, when no value is specified */
        if (ret)
            val = par->default_value;

        pr_debug("found %s with value %u\n", par->property, val);
        cfg[*ncfg] = pinconf_to_config_packed(par->param, val);
        (*ncfg)++;
    }
}

count 수 만큼 루프를 돌며 디바이스 노드에서 속성을 찾아 출력 인자인 cfg 배열에 찾은 속성의 인덱스 번호를 하나씩 채워 넣는다.

 

pinctrl_utils_reserve_map()

drivers/pinctrl/pinctrl-utils.c

int pinctrl_utils_reserve_map(struct pinctrl_dev *pctldev,
        struct pinctrl_map **map, unsigned *reserved_maps,
        unsigned *num_maps, unsigned reserve)
{
    unsigned old_num = *reserved_maps;
    unsigned new_num = *num_maps + reserve;
    struct pinctrl_map *new_map;

    if (old_num >= new_num)
        return 0;

    new_map = krealloc(*map, sizeof(*new_map) * new_num, GFP_KERNEL);
    if (!new_map) { 
        dev_err(pctldev->dev, "krealloc(map) failed\n");
        return -ENOMEM;
    }

    memset(new_map + old_num, 0, (new_num - old_num) * sizeof(*new_map));

    *map = new_map;
    *reserved_maps = new_num;
    return 0; 
}
EXPORT_SYMBOL_GPL(pinctrl_utils_reserve_map);

필요한 만큼 pinctrl_map 배열을 확장하여 할당한다.

  • 2 단계 이상의 복합 노드로 구성될 때 이 함수가 호출될 때 마다 기존 pinctrl_map 배열보다 점점 커진다. 이 함수에서는 기존 할당된 pinctrl_map 배열을 버리고 더 커진 새 pinctrl_map 배열을 생성하고 기존 데이터를 복제하여 유지한다.

 

  • 코드 라인 5~10에서 기존 맵 수인 reserved_maps와 새로 만들 num_maps + reserve 와 비교하여 새 맵이 더 크지 않으면 그냥 성공(0) 결과로 새로운 맵 할당 없이 함수를 빠져나간다.
  • 코드 라인 12~16에서 새로 만들어야 하는 맵 수만큼 pinctrl_map 배열을 확장한다.
    • krealloc() 함수를 사용 시 새로 할당한 영역에 기존 기존 데이터는 그대로 복제되어 유지된다.
  • 코드 라인 18~22에서 기존 맵 수보다 추가 생성된 맵 수 만큼 생성한 맵의 뒷 부분을 0으로 클리어한다.

 

pinctrl_utils_add_map_mux()

drivers/pinctrl/pinctrl-utils.c

int pinctrl_utils_add_map_mux(struct pinctrl_dev *pctldev,
        struct pinctrl_map **map, unsigned *reserved_maps,
        unsigned *num_maps, const char *group,
        const char *function)
{   
    if (WARN_ON(*num_maps == *reserved_maps))
        return -ENOSPC;

    (*map)[*num_maps].type = PIN_MAP_TYPE_MUX_GROUP;
    (*map)[*num_maps].data.mux.group = group;
    (*map)[*num_maps].data.mux.function = function;
    (*num_maps)++;

    return 0;
}   
EXPORT_SYMBOL_GPL(pinctrl_utils_add_map_mux);

pinmux 매핑 맵의 자료 구조를 채운다.

 

pinctrl_utils_add_map_configs()

drivers/pinctrl/pinctrl-utils.c

int pinctrl_utils_add_map_configs(struct pinctrl_dev *pctldev,
        struct pinctrl_map **map, unsigned *reserved_maps,
        unsigned *num_maps, const char *group,
        unsigned long *configs, unsigned num_configs,
        enum pinctrl_map_type type)
{
    unsigned long *dup_configs;

    if (WARN_ON(*num_maps == *reserved_maps))
        return -ENOSPC;

    dup_configs = kmemdup(configs, num_configs * sizeof(*dup_configs),
                  GFP_KERNEL);
    if (!dup_configs) {
        dev_err(pctldev->dev, "kmemdup(configs) failed\n");
        return -ENOMEM;
    }

    (*map)[*num_maps].type = type;
    (*map)[*num_maps].data.configs.group_or_pin = group;
    (*map)[*num_maps].data.configs.configs = dup_configs;
    (*map)[*num_maps].data.configs.num_configs = num_configs;
    (*num_maps)++;

    return 0;
}
EXPORT_SYMBOL_GPL(pinctrl_utils_add_map_configs);

pinconf 매핑 맵의 자료 구조를 채운다.

  • configs 배열을 복제하여 사용하는 이유는 이 함수를 호출하는 곳에서 원래 configs 배열을 할당 해제한다.

 

추후 사용하기 위해 디바이스 트리 매핑들 등록

dt_remember_or_free_map()

drivers/pinctrl/devicetree.c

static int dt_remember_or_free_map(struct pinctrl *p, const char *statename,
                   struct pinctrl_dev *pctldev,
                   struct pinctrl_map *map, unsigned num_maps)
{
    int i;
    struct pinctrl_dt_map *dt_map;

    /* Initialize common mapping table entry fields */
    for (i = 0; i < num_maps; i++) {
        map[i].dev_name = dev_name(p->dev);
        map[i].name = statename;
        if (pctldev)
            map[i].ctrl_dev_name = dev_name(pctldev->dev);
    }

    /* Remember the converted mapping table entries */
    dt_map = kzalloc(sizeof(*dt_map), GFP_KERNEL);
    if (!dt_map) {
        dev_err(p->dev, "failed to alloc struct pinctrl_dt_map\n");
        dt_free_map(pctldev, map, num_maps);
        return -ENOMEM;
    }

    dt_map->pctldev = pctldev;
    dt_map->map = map;
    dt_map->num_maps = num_maps;
    list_add_tail(&dt_map->node, &p->dt_maps);

    return pinctrl_register_map(map, num_maps, false);
}

추후 사용하기 위해 파싱되어 알아온 매핑 맵들을 다음 두 위치에 추가한다.

  • pinctrl_dt_map 구조체를 생성한 후 매핑 맵들을 추가한다. 생성한 pinctrl_dt_map은 pinctrl->dt_maps 리스트에 추가하여 관리한다.
  • pinctrl_maps 구조체를 생성한 후 매핑 맵들을 추가한다. 생성한 pinctrl_maps 구조체는 전역 pinctrl_maps 리스트에 추가하여 관리한다.

 

  • 코드 라인 9~14에서 파싱하여 알아온 매핑 맵들을 그 수만큼 루프를 돌며 디바이스 명과 스테이트 명을 부여한다. pin control 디바이스도 지정된 경우 pin control 디바이스 명도 부여한다.
  • 코드 라인 17~27에서 pinctrl_dt_map 구조체를 만들고 그 밑으로 파싱하여 알아온 매핑맵들을 추가한다.
  • 코드 라인 29에서 pinctrl_maps 구조체를 만들고 그 밑으로 파싱하여 알아온 매핑맵들을 추가한다.
    • 세 번째 인수에 false를 주어 매핑 맵들의 복제는 하지 않는다.

 

pinctrl_register_map()

이 함수는 pinctrl_maps 구조체를 할당하고 인자로 전달받은 매핑들을 대입한 후 전역 pinctrl_maps 리스트에 추가한다.

drivers/pinctrl/core.c – 1/2

int pinctrl_register_map(const struct pinctrl_map *maps, unsigned num_maps,
			 bool dup)
{
	int i, ret;
	struct pinctrl_maps *maps_node;

	pr_debug("add %u pinctrl maps\n", num_maps);

	/* First sanity check the new mapping */
	for (i = 0; i < num_maps; i++) {
		if (!maps[i].dev_name) {
			pr_err("failed to register map %s (%d): no device given\n",
			       maps[i].name, i);
			return -EINVAL;
		}

		if (!maps[i].name) {
			pr_err("failed to register map %d: no map name given\n",
			       i);
			return -EINVAL;
		}

		if (maps[i].type != PIN_MAP_TYPE_DUMMY_STATE &&
				!maps[i].ctrl_dev_name) {
			pr_err("failed to register map %s (%d): no pin control device given\n",
			       maps[i].name, i);
			return -EINVAL;
		}

		switch (maps[i].type) {
		case PIN_MAP_TYPE_DUMMY_STATE:
			break;
		case PIN_MAP_TYPE_MUX_GROUP:
			ret = pinmux_validate_map(&maps[i], i);
			if (ret < 0)
				return ret;
			break;
		case PIN_MAP_TYPE_CONFIGS_PIN:
		case PIN_MAP_TYPE_CONFIGS_GROUP:
			ret = pinconf_validate_map(&maps[i], i);
			if (ret < 0)
				return ret;
			break;
		default:
			pr_err("failed to register map %s (%d): invalid type given\n",
			       maps[i].name, i);
			return -EINVAL;
		}
	}
  • 코드 라인 10~49에서 인자로 전달받은 maps 배열 수만큼 루프를 돌며 요청 타입에 따른 sanity 체크를 수행한다.

 

drivers/pinctrl/core.c – 2/2

	maps_node = kzalloc(sizeof(*maps_node), GFP_KERNEL);
	if (!maps_node)
		return -ENOMEM;

	maps_node->num_maps = num_maps;
	if (dup) {
		maps_node->maps = kmemdup(maps, sizeof(*maps) * num_maps,
					  GFP_KERNEL);
		if (!maps_node->maps) {
			kfree(maps_node);
			return -ENOMEM;
		}
	} else {
		maps_node->maps = maps;
	}

	mutex_lock(&pinctrl_maps_mutex);
	list_add_tail(&maps_node->node, &pinctrl_maps);
	mutex_unlock(&pinctrl_maps_mutex);

	return 0;
}
  • 코드 라인 1~15에서 pinctrl_maps 구조체를 할당한 후 인자로 전달받은 매핑 배열인 maps를 가리키게한다. 입력 인자 dup에 따라 매핑 배열을 복제할 수도 있다.
  • 코드 라인 17~19에서 할당받은 pinctrl_maps 구조체를 전역 리스트 pinctrl_maps에 추가한다.

 

스테이트별 설정(setting) 관리

디바이스 트리로부터 pinmux/pinconf 노드를 파싱하여 관리되고 있는 매핑 맵들을 스테이트 별로 설정들을 관리하도록 준비한다. 아래 그림은 single 스테이트를 사용한 경우이다.

  • pinmux/pinconf 매핑 맵에 있는 문자열을 setting으로 변환할 때 setting에는 인덱스 숫자로 변환되어 사용되도록 한다.
    • “gpio_0_1_grp” 그룹명은 2번 인덱스로 변경
    • “gpio” 펑션명은 2번 인덱스(selector)로 변경
    • “uart3_sin” 핀명은 67번 인덱스로 변경
    • unsigned long으로 표현된 configs 배열은 그대로 변경없이 사용한다.

 

add_setting()

drivers/pinctrl/core.c

static int add_setting(struct pinctrl *p, struct pinctrl_dev *pctldev,
               const struct pinctrl_map *map)
{
    struct pinctrl_state *state;
    struct pinctrl_setting *setting;
    int ret;

    state = find_state(p, map->name);
    if (!state)
        state = create_state(p, map->name);
    if (IS_ERR(state))
        return PTR_ERR(state);

    if (map->type == PIN_MAP_TYPE_DUMMY_STATE)
        return 0;

    setting = kzalloc(sizeof(*setting), GFP_KERNEL);
    if (!setting)
        return -ENOMEM;

    setting->type = map->type;

    if (pctldev)
        setting->pctldev = pctldev;
    else
        setting->pctldev =
            get_pinctrl_dev_from_devname(map->ctrl_dev_name);
    if (!setting->pctldev) {
        kfree(setting);
        /* Do not defer probing of hogs (circular loop) */
        if (!strcmp(map->ctrl_dev_name, map->dev_name))
            return -ENODEV;
        /*
         * OK let us guess that the driver is not there yet, and
         * let's defer obtaining this pinctrl handle to later...
         */
        dev_info(p->dev, "unknown pinctrl device %s in map entry, deferring probe",
            map->ctrl_dev_name);
        return -EPROBE_DEFER;
    }

    setting->dev_name = map->dev_name;

    switch (map->type) {
    case PIN_MAP_TYPE_MUX_GROUP:
        ret = pinmux_map_to_setting(map, setting);
        break;
    case PIN_MAP_TYPE_CONFIGS_PIN:
    case PIN_MAP_TYPE_CONFIGS_GROUP:
        ret = pinconf_map_to_setting(map, setting);
        break;
    default:
        ret = -EINVAL;
        break;
    }
    if (ret < 0) {
        kfree(setting);
        return ret;
    }

    list_add_tail(&setting->node, &state->settings);

    return 0;
}

인자로 요청한 스테이트명에 해당하는 스테이트 밑으로 pinctrl_state 구조체를 만들고 디바이스 트리 pinmux/pinconf 매핑 맵들을 변환하여 실제 사용하는 인덱스 숫자로 세팅들을 만들어 준비한다.

  • 코드 라인 8~12에서 인자로 주어진 스테이트명으로 스테이트를 검색한 후 처음 사용하는 경우 pinctrl_state 구조체를 생성하고 초기화한다.
  • 코드 라인 14~15에서 dummy 타입 매핑이 발견되면 생략하고 함수를 빠져나간다.
  • 코드 라인 17~42에서 pinctrl_setting 구조체를 할당하고 매핑 맵들의 실제 pinmux/pinconf 매핑 정보를 제외한 일반 정보로 채운다.
  • 코드 라인 44~59에서 pinmux 및 pinconf 매핑 타입에 따라 pinctrl_setting 구조체를 할당하고 매핑 정보에 해당하는 매핑 인덱스 값으로 변환하여 대입한다.
  • 코드 라인 61~63에서 생성한 pinctrl_setting 구조체를 해당 state에 추가하고 성공(0)을 반환한다.

 

pinmux_map_to_setting()

drivers/pinctrl/pinmux.c

int pinmux_map_to_setting(const struct pinctrl_map *map,
              struct pinctrl_setting *setting)
{
    struct pinctrl_dev *pctldev = setting->pctldev;
    const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
    char const * const *groups;
    unsigned num_groups;
    int ret;
    const char *group;

    if (!pmxops) {
        dev_err(pctldev->dev, "does not support mux function\n");
        return -EINVAL;
    }

    ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function);
    if (ret < 0) {
        dev_err(pctldev->dev, "invalid function %s in map table\n",
            map->data.mux.function);
        return ret;
    }
    setting->data.mux.func = ret;
    
    ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
                      &groups, &num_groups);
    if (ret < 0) {
        dev_err(pctldev->dev, "can't query groups for function %s\n",
            map->data.mux.function);
        return ret;
    }
    if (!num_groups) {
        dev_err(pctldev->dev,
            "function %s can't be selected on any group\n",
            map->data.mux.function);
        return -EINVAL;
    }
    if (map->data.mux.group) {
        group = map->data.mux.group;
        ret = match_string(groups, num_groups, group);
        if (ret < 0) {
            dev_err(pctldev->dev,
                "invalid group \"%s\" for function \"%s\"\n",
                group, map->data.mux.function);
            return ret;
        }
    } else {
        group = groups[0];
    }

    ret = pinctrl_get_group_selector(pctldev, group);
    if (ret < 0) {
        dev_err(pctldev->dev, "invalid group %s in map table\n",
            map->data.mux.group);
        return ret;
    }
    setting->data.mux.group = ret;

    return 0;
}

pinmux 매핑 맵을 setting으로 변환한다. 매핑 맵이 문자열로 구성되어있는데 이들을  setting에 사용할 인덱스 숫자로 바꾼다.

  • 코드 라인 11~14 pinmux 오퍼레이션이 준비되지 않은 pin controller 디바이스인 경우 pinmux 펑션이 지원되지 않는다는 에러 메시지를 출력하고 함수를 빠져나간다.
  • 코드 라인 16~22에서 function 이름으로 selector 값을 찾아와서 setting의 function 값에 대입한다.
    • ns2 통해 function 명이 “uart0” 인 경우  -> 4
  • 코드 라인 24~36에서 function에서 사용할 수 있는 그룹명들을 groups에 알아온다.
  • 코드 라인 37~45에서 디바이스 트리 pinmux 매핑 맵이 요구하는 그룹명이 위의 groups 배열에서 검색하여 매치되지 않으면 에러를 출력하고 함수를 빠져나간다.
  • 코드 라인 46~48에서 pinmux 매핑 맵에 group 명이 지정되지 않은 경우 pinmux 디바이스 드라이버에서 검색한 그룹의 첫 번째 그룹명을 사용한다.
  • 코드 라인 50~56에서 group명으로 pinmux 디바이스 드라이버가 관리하는 그룹명에서 제공하는group명에 해당하는 selector 인덱스 값을 알아온다.
    • ns2 예) “uart0_modem_grp” 그룹명으로 검색하는 경우 21이 반환된다.

 

pinmux_func_name_to_selector()

drivers/pinctrl/pinmux.c

static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
                                        const char *function)
{
        const struct pinmux_ops *ops = pctldev->desc->pmxops;
        unsigned nfuncs = ops->get_functions_count(pctldev);
        unsigned selector = 0;

        /* See if this pctldev has this function */
        while (selector < nfuncs) {
                const char *fname = ops->get_function_name(pctldev, selector);

                if (!strcmp(function, fname))
                        return selector;

                selector++;
        }

        dev_err(pctldev->dev, "function '%s' not supported\n", function);
        return -EINVAL;
}

function 이름으로 selector 인덱스 값을 찾아온다.

  • 코드 라인 4~5에서 pin controller 디바이스 드라이버의 pinmux 오퍼레이션에 등록된 (*get_functions_count) 후크 함수를 통해 function의 개수를 알아온다.
    • 예) ns2_get_functions_count() 함수를 사용하여 8을 구해온다.
      • ns2 펑션은 nand, nor, gpio, pcie, uart0, uart1, uart2, pwm 까지 8가지이다.
  • 코드 라인 9~16에서 0번부터 시작하여 함수 개수 만큼 루프를 돌며 디바이스 드라이버의 pinmux 오퍼레이션에 등록된 (*get_function_name)을 통해 함수명을 알아온 function 명과 인자로 요청한 function 명이 일치할 때까지 비교한다. 일치하는 경우 selector 인덱스 값을 반환한다.
    • 예) ns2_get_function_name() 함수를 사용하여 0~7 범위에서 구해온다.

 

pinconf_map_to_setting()

drivers/pinctrl/pinconf.c

int pinconf_map_to_setting(const struct pinctrl_map *map,
              struct pinctrl_setting *setting)
{   
    struct pinctrl_dev *pctldev = setting->pctldev;
    int pin;
        
    switch (setting->type) {
    case PIN_MAP_TYPE_CONFIGS_PIN:
        pin = pin_get_from_name(pctldev,
                    map->data.configs.group_or_pin);
        if (pin < 0) {
            dev_err(pctldev->dev, "could not map pin config for \"%s\"",
                map->data.configs.group_or_pin);
            return pin;
        }
        setting->data.configs.group_or_pin = pin;
        break;
    case PIN_MAP_TYPE_CONFIGS_GROUP:
        pin = pinctrl_get_group_selector(pctldev,
                     map->data.configs.group_or_pin);
        if (pin < 0) {
            dev_err(pctldev->dev, "could not map group config for \"%s\"",
                map->data.configs.group_or_pin);
            return pin;
        }
        setting->data.configs.group_or_pin = pin;
        break;
    default:
        return -EINVAL;
    }   

    setting->data.configs.num_configs = map->data.configs.num_configs;
    setting->data.configs.configs = map->data.configs.configs;

    return 0;
}

pinconf 매핑 맵을 setting으로 변환한다. 매핑 맵이 문자열로 구성되어있는데 이들을  setting에 사용할 인덱스 숫자로 바꾼다.

  • 코드 라인 7~17에서 pinconf 매핑이 핀 타입인 경우 pin명 에 해당하는 인덱스 값을 알아와서 setting에 대입한다.
    • ns2 통해 function 명이 “uart0_sin” 인 경우  -> 67
  • 코드 라인 18~27에서 pinconf 매핑이 그룹 타입인 경우 group명 에 해당하는 인덱스 값을 알아와서 setting에 대입한다.
  • 코드 라인 32~33에서 pinconf 매핑에 있는 unsigned long 배열 타입의 configs는 그대로 setting에서도 사용한다.

 

Pin Control 디바이스 드라이버 진입부

Pin Controller + GPIO controller + interrupt controller 드라이버 등록 – for rpi2

rpi2용 드라이버에는 pin controller 뿐만 아니라 gpio controller와 interrupt controller까지 등록하여 사용하는 코드로 구성되어 있다.

  • rpi2는 gpio 핀을 통해 외부 인터럽트를 수신할 수 있다.

drivers/pinctrl/pinctrl-bcm2835.c

static const struct of_device_id bcm2835_pinctrl_match[] = {
        { .compatible = "brcm,bcm2835-gpio" },
        {}
};
MODULE_DEVICE_TABLE(of, bcm2835_pinctrl_match);

static struct platform_driver bcm2835_pinctrl_driver = {
        .probe = bcm2835_pinctrl_probe,
        .remove = bcm2835_pinctrl_remove,
        .driver = {
                .name = MODULE_NAME,
                .owner = THIS_MODULE,
                .of_match_table = bcm2835_pinctrl_match,
        },
};
module_platform_driver(bcm2835_pinctrl_driver);

 

bcm2835_pinctrl_probe()

drivers/pinctrl/bcm/pinctrl-bcm2835.c – 1/3

static int bcm2835_pinctrl_probe(struct platform_device *pdev)
{
        struct device *dev = &pdev->dev;
        struct device_node *np = dev->of_node;
        struct bcm2835_pinctrl *pc;
        struct resource iomem;
        int err, i;
        BUILD_BUG_ON(ARRAY_SIZE(bcm2835_gpio_pins) != BCM2835_NUM_GPIOS);
        BUILD_BUG_ON(ARRAY_SIZE(bcm2835_gpio_groups) != BCM2835_NUM_GPIOS);

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

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

        err = of_address_to_resource(np, 0, &iomem);
        if (err) {
                dev_err(dev, "could not get IO memory\n");
                return err;
        }

        pc->base = devm_ioremap_resource(dev, &iomem);
        if (IS_ERR(pc->base))
                return PTR_ERR(pc->base);
  • 코드 라인 11~13에서 bcm2835_pinctrl 구조체를 할당받는다.
  • 코드 라인 15~16에서 인자로 전달받은 플랫폼 디바이스와 bcm2835_pinctrl 구조체와 상호 관계를 연결해둔다.
    • &pdev->dev->driver_data = pc
    • pc->dev = &pdev->dev
  • 코드 라인 18~22에서 디바이스 노드의 ranges 속성에서 읽어들인 IO 주소와 크기를 알아와서 리소스 타입인 iomem에 저장한다.
  • 코드 라인 24~26에서 iomem 리소스 정보로 io 매핑을 한다. 반환되는 결과는 매핑한 가상 주소이다.

 

drivers/pinctrl/bcm/pinctrl-bcm2835.c – 2/3

.	pc->gpio_chip = bcm2835_gpio_chip;
	pc->gpio_chip.parent = dev;
	pc->gpio_chip.of_node = np;

	for (i = 0; i < BCM2835_NUM_BANKS; i++) {
		unsigned long events;
		unsigned offset;

		/* clear event detection flags */
		bcm2835_gpio_wr(pc, GPREN0 + i * 4, 0);
		bcm2835_gpio_wr(pc, GPFEN0 + i * 4, 0);
		bcm2835_gpio_wr(pc, GPHEN0 + i * 4, 0);
		bcm2835_gpio_wr(pc, GPLEN0 + i * 4, 0);
		bcm2835_gpio_wr(pc, GPAREN0 + i * 4, 0);
		bcm2835_gpio_wr(pc, GPAFEN0 + i * 4, 0);

		/* clear all the events */
		events = bcm2835_gpio_rd(pc, GPEDS0 + i * 4);
		for_each_set_bit(offset, &events, 32)
			bcm2835_gpio_wr(pc, GPEDS0 + i * 4, BIT(offset));

		spin_lock_init(&pc->irq_lock[i]);
	}

	err = gpiochip_add_data(&pc->gpio_chip, pc);
	if (err) {
		dev_err(dev, "could not add GPIO chip\n");
		return err;
	}

	err = gpiochip_irqchip_add(&pc->gpio_chip, &bcm2835_gpio_irq_chip,
				   0, handle_level_irq, IRQ_TYPE_NONE);
	if (err) {
		dev_info(dev, "could not add irqchip\n");
		return err;
	}

위의 코드들은 gpio 컨트롤러를 등록하는 부분들이다. (여기에서는 설명 생략)

 

drivers/pinctrl/bcm/pinctrl-bcm2835.c – 3/3

	for (i = 0; i < BCM2835_NUM_IRQS; i++) {
		pc->irq[i] = irq_of_parse_and_map(np, i);

		if (pc->irq[i] == 0)
			continue;

		/*
		 * Use the same handler for all groups: this is necessary
		 * since we use one gpiochip to cover all lines - the
		 * irq handler then needs to figure out which group and
		 * bank that was firing the IRQ and look up the per-group
		 * and bank data.
		 */
		gpiochip_set_chained_irqchip(&pc->gpio_chip,
					     &bcm2835_gpio_irq_chip,
					     pc->irq[i],
					     bcm2835_gpio_irq_handler);
	}

	pc->pctl_dev = devm_pinctrl_register(dev, &bcm2835_pinctrl_desc, pc);
	if (IS_ERR(pc->pctl_dev)) {
		gpiochip_remove(&pc->gpio_chip);
		return PTR_ERR(pc->pctl_dev);
	}

	pc->gpio_range = bcm2835_pinctrl_gpio_range;
	pc->gpio_range.base = pc->gpio_chip.base;
	pc->gpio_range.gc = &pc->gpio_chip;
	pinctrl_add_gpio_range(pc->pctl_dev, &pc->gpio_range);

	return 0;
}
  • 코드 라인 1~18에서 이 부분의 코드들은 interrupt controller를 등록하는 부분이다. (여기에서는 설명은 생략)
  • 코드 라인 20~24에서 pinctrl, pinmux 및 pinconf의 오퍼레이션들과 핀 디스크립터들을 포함한 pinctrl 디스크립터 정보로 pin controller를 등록한다.
  • 코드 라인 26~29에서 gpio range를 등록한다. (deprecated)

 

Pin Control 드라이버 등록 – for ns2

rpi2 드라이버와는 달리 오로지 pin controller 드라이버만으로 구성되어 있다.

drivers/pinctrl/bcm/pinctrl-ns2-mux.c

static const struct of_device_id ns2_pinmux_of_match[] = {
        {.compatible = "brcm,ns2-pinmux"},
        { }
};

static struct platform_driver ns2_pinmux_driver = {
        .driver = {
                .name = "ns2-pinmux",
                .of_match_table = ns2_pinmux_of_match,
        },
        .probe = ns2_pinmux_probe,
};

static int __init ns2_pinmux_init(void)
{
        return platform_driver_register(&ns2_pinmux_driver);
}
arch_initcall(ns2_pinmux_init);

 

ns2_pinmux_probe()

drivers/pinctrl/bcm/pinctrl-ns2-mux.c

static int ns2_pinmux_probe(struct platform_device *pdev)
{
        struct ns2_pinctrl *pinctrl;
        struct resource *res;
        int i, ret;
        struct pinctrl_pin_desc *pins;
        unsigned int num_pins = ARRAY_SIZE(ns2_pins);

        pinctrl = devm_kzalloc(&pdev->dev, sizeof(*pinctrl), GFP_KERNEL);
        if (!pinctrl)
                return -ENOMEM;

        pinctrl->dev = &pdev->dev; 
        platform_set_drvdata(pdev, pinctrl);
        spin_lock_init(&pinctrl->lock);

        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        pinctrl->base0 = devm_ioremap_resource(&pdev->dev, res);
        if (IS_ERR(pinctrl->base0))
                return PTR_ERR(pinctrl->base0);

        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
        pinctrl->base1 = devm_ioremap_nocache(&pdev->dev, res->start,
                                        resource_size(res));
        if (!pinctrl->base1) {
                dev_err(&pdev->dev, "unable to map I/O space\n");
                return -ENOMEM;
        }

        res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
        pinctrl->pinconf_base = devm_ioremap_resource(&pdev->dev, res);
        if (IS_ERR(pinctrl->pinconf_base))
                return PTR_ERR(pinctrl->pinconf_base);

        ret = ns2_mux_log_init(pinctrl);
        if (ret) {
                dev_err(&pdev->dev, "unable to initialize IOMUX log\n");
                return ret;
        }

        pins = devm_kcalloc(&pdev->dev, num_pins, sizeof(*pins), GFP_KERNEL);
        if (!pins)
                return -ENOMEM;

        for (i = 0; i < num_pins; i++) {
                pins[i].number = ns2_pins[i].pin;
                pins[i].name = ns2_pins[i].name;
                pins[i].drv_data = &ns2_pins[i];
        }

        pinctrl->groups = ns2_pin_groups;
        pinctrl->num_groups = ARRAY_SIZE(ns2_pin_groups);
        pinctrl->functions = ns2_pin_functions;
        pinctrl->num_functions = ARRAY_SIZE(ns2_pin_functions);
        ns2_pinctrl_desc.pins = pins;
        ns2_pinctrl_desc.npins = num_pins;

        pinctrl->pctl = pinctrl_register(&ns2_pinctrl_desc, &pdev->dev,
                        pinctrl);
        if (IS_ERR(pinctrl->pctl)) {
                dev_err(&pdev->dev, "unable to register IOMUX pinctrl\n");
                return PTR_ERR(pinctrl->pctl);
        }
 
        return 0;
}
  • 코드 라인 9~11에서 ns2_pinctrl 구조체를 할당받는다.
  • 코드 라인 13~14에서 인자로 전달받은 플랫폼 디바이스와 bcm2835_pinctrl 구조체와 상호 관계를 연결해둔다.
    • &pdev->dev->driver_data = pc
    • pc->dev = &pdev->dev
  • 코드 라인 17~20에서 플랫폼 디바이스에 저장된 첫 번째 IOMUX 레지스터에 대한 IO 리소스 메모리 정보를 알아온 후 매핑한다. 반환되는 결과는 매핑한 가상 주소이다.
  • 코드 라인 22~28에서 플랫폼 디바이스에 저장된 두 번째 IOMUX 레지스터에 대한 리소스 메모리 정보를 알아온 후 매핑한다. 반환되는 결과는 매핑한 가상 주소이다.
  • 코드 라인 30~33에서 플랫폼 디바이스에 저장된 configuration 레지스터에 대한 리소스 메모리 정보를 알아온 후 매핑한다. 반환되는 결과는 매핑한 가상 주소이다.
  • 코드 라인 35~39에서 최대 NS2_NUM_IOMUX(19)개까지 관리하는 IOMUX 정보를 초기화한다.
  • 코드 라인 41~49에서 pinctrl_pin_desc 구조체를 할당받은 후 컴파일 타임에 구성한 ns2 핀 정보로 대입한다.
  • 코드 라인 51~63에서 pinctrl, pinmux 및 pinconf의 오퍼레이션들과 핀 디스크립터들을 포함한 pinctrl 디스크립터 정보로 pin controller를 등록한다.

 

Pin Controller 등록

pin controller를 등록하면 디바이스 트리를 통해 부트업 시 pinmux 및 pinconf 매핑 항목들을 동작시킬 수 있다.

 

pinctrl_register() 함수를 통해 등록되는 pin controller의 관계는 다음과 같다.

 

pinctrl_register()

이 함수는 pin controller 디바이스를 생성한 후 등록하고 반환한다. 더 자세히 알아보면 다음과 같다.

  • 인자로 전달받은 pinctrl 디스크립터, 디바이스 및 디바이스 데이터를 사용하여 pin controller 디바이스를 생성한다.
  • 내부에서는 pinctrl 디스크립터에서 제공한 pin 디스크립터들을 RADIX 트리에 등록한다.
  • “default” 스테이트를 검색하고 찾은 경우 등록된 pinmux/pinconf 매핑들을 HW에 적용한다.
  • “sleep” 스테이트를 검색하여 알아온다.

drivers/pinctrl/core.c – 1/2

/**
 * pinctrl_register() - register a pin controller device
 * @pctldesc: descriptor for this pin controller
 * @dev: parent device for this pin controller
 * @driver_data: private pin controller data for this pin controller
 */
struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,
                                    struct device *dev, void *driver_data)
{
        struct pinctrl_dev *pctldev;
        int ret;

        if (!pctldesc)
                return ERR_PTR(-EINVAL);
        if (!pctldesc->name)
                return ERR_PTR(-EINVAL);

        pctldev = kzalloc(sizeof(*pctldev), GFP_KERNEL);
        if (pctldev == NULL) {
                dev_err(dev, "failed to alloc struct pinctrl_dev\n");
                return ERR_PTR(-ENOMEM);
        }

        /* Initialize pin control device struct */
        pctldev->owner = pctldesc->owner;
        pctldev->desc = pctldesc;
        pctldev->driver_data = driver_data;
        INIT_RADIX_TREE(&pctldev->pin_desc_tree, GFP_KERNEL);
        INIT_LIST_HEAD(&pctldev->gpio_ranges);
        pctldev->dev = dev;
        mutex_init(&pctldev->mutex);

        /* check core ops for sanity */
        ret = pinctrl_check_ops(pctldev);
        if (ret) {
                dev_err(dev, "pinctrl ops lacks necessary functions\n");
                goto out_err;
        }

        /* If we're implementing pinmuxing, check the ops for sanity */
        if (pctldesc->pmxops) {
                ret = pinmux_check_ops(pctldev);
                if (ret)
                        goto out_err;
        }

        /* If we're implementing pinconfig, check the ops for sanity */
        if (pctldesc->confops) {
                ret = pinconf_check_ops(pctldev);
                if (ret)
                        goto out_err;
        }
  • 코드 라인 18~31에서 pinctrl_dev 구조체를 할당받고 초기화한다.
  • 코드 라인 34~52에서 pinctrl, pinmux, pinconf 오퍼레이션에 대한 sanity 체크를 수행한다.

 

drivers/pinctrl/core.c – 2/2

        /* Register all the pins */
        dev_dbg(dev, "try to register %d pins ...\n",  pctldesc->npins);
        ret = pinctrl_register_pins(pctldev, pctldesc->pins, pctldesc->npins);
        if (ret) {
                dev_err(dev, "error during pin registration\n");
                pinctrl_free_pindescs(pctldev, pctldesc->pins,
                                      pctldesc->npins);
                goto out_err;
        }

        mutex_lock(&pinctrldev_list_mutex);
        list_add_tail(&pctldev->node, &pinctrldev_list);
        mutex_unlock(&pinctrldev_list_mutex);

        pctldev->p = pinctrl_get(pctldev->dev);

        if (!IS_ERR(pctldev->p)) {
                pctldev->hog_default =
                        pinctrl_lookup_state(pctldev->p, PINCTRL_STATE_DEFAULT);
                if (IS_ERR(pctldev->hog_default)) {
                        dev_dbg(dev, "failed to lookup the default state\n");
                } else {
                        if (pinctrl_select_state(pctldev->p,
                                                pctldev->hog_default))
                                dev_err(dev,
                                        "failed to select default state\n");
                }

                pctldev->hog_sleep =
                        pinctrl_lookup_state(pctldev->p,
                                                    PINCTRL_STATE_SLEEP);
                if (IS_ERR(pctldev->hog_sleep))
                        dev_dbg(dev, "failed to lookup the sleep state\n");
        }

        pinctrl_init_device_debugfs(pctldev);

        return pctldev;

out_err:
        mutex_destroy(&pctldev->mutex);
        kfree(pctldev);
        return ERR_PTR(ret);
}
EXPORT_SYMBOL_GPL(pinctrl_register);
  • 코드 라인 3~9에서 선언된 모든 핀들을 등록시킨다.
  • 코드 라인 11~13에서 전역 리스트 pinctrldev_list에 할당받아 초기화한 pinctrl_dev 구조체를 추가한다.
  • 코드 라인 15에서 디바이스에 대한 pinctrl 구조체를 찾아 얻어온다. pinctrl이 발견되지 않는 경우 create_pinctrl() 함수를 호출하여 pinctrl을 생성해온다.
    • pinctrl을 생성 시에는 pinctrl_dt_to_map() 함수를 호출하여 디바이스 트리를 파싱하여 pinmux/pinconf 매핑 항목들을 pinctrrl_map 구조체에 담아 등록한다. 그런 후 매핑들 수만큼 add_setting() 함수를 호출하여 pinctrl_map을 사용하여 pinctrl_setting 구조체를 생성해내어 등록한다.
  • 코드 라인 17~27에서 pinctrl을 잘 가져온 경우 “default” 상태를 검색하고 찾은 경우 등록된 pinmux/pinconf 매핑들을 HW에 적용한다.
  • 코드 라인 29~33에서 “sleep” 상태를 검색해온다.
  • 코드 라인 36에서 debugfs 용도로 각종 virtual file들을 생성한다.

 

스테이트 관리

pinctrl_lookup_state()

drivers/pinctrl/core.c

/**
 * pinctrl_lookup_state() - retrieves a state handle from a pinctrl handle
 * @p: the pinctrl handle to retrieve the state from
 * @name: the state name to retrieve
 */
struct pinctrl_state *pinctrl_lookup_state(struct pinctrl *p,
                                                 const char *name)
{
        struct pinctrl_state *state;

        state = find_state(p, name);
        if (!state) {
                if (pinctrl_dummy_state) {
                        /* create dummy state */
                        dev_dbg(p->dev, "using pinctrl dummy state (%s)\n",
                                name);
                        state = create_state(p, name);
                } else
                        state = ERR_PTR(-ENODEV);
        }

        return state;
}
EXPORT_SYMBOL_GPL(pinctrl_lookup_state);

인자로 주어진 pinctrl 구조체와 스테이트 이름으로  pinctrl_state 구조체를 찾아온다.

 

find_state()

drivers/pinctrl/core.c

static struct pinctrl_state *find_state(struct pinctrl *p,
					const char *name)
{
	struct pinctrl_state *state;

	list_for_each_entry(state, &p->states, node)
		if (!strcmp(state->name, name))
			return state;

	return NULL;
}

인자로 주어진 pinctrl 구조체의 멤버 states 리스트에서 스테이트 이름으로  pinctrl_state 구조체를 찾아온다. 없으면 null을 반환한다.

 

create_state()

drivers/pinctrl/core.c

static struct pinctrl_state *create_state(struct pinctrl *p,
                                          const char *name)
{
        struct pinctrl_state *state;

        state = kzalloc(sizeof(*state), GFP_KERNEL);
        if (state == NULL) {
                dev_err(p->dev,
                        "failed to alloc struct pinctrl_state\n");
                return ERR_PTR(-ENOMEM);
        }

        state->name = name;
        INIT_LIST_HEAD(&state->settings);

        list_add_tail(&state->node, &p->states);

        return state;
}

pinctrl_state 구조체를 생성한다.

  • 생성한 pinctrl_state 구조체에는 두 번째 인자로 주어진 스테이트 명을 대입한다.
  • 그리고 첫 번째 인자로 받은 pinctrl 구조체에서 멤버 states 리스트에 생성한 구조체를 추가한 후 반환한다.

 

pinctrl_select_state()

state를 선택하고 pinconf/pinmux setting을 HW에 적용한다. 이미 state가 선택된 경우 무시하고 빠져나온다.

drivers/pinctrl/core.c – 1/2

/**
 * pinctrl_select_state() - select/activate/program a pinctrl state to HW
 * @p: the pinctrl handle for the device that requests configuration
 * @state: the state handle to select/activate/program
 */
int pinctrl_select_state(struct pinctrl *p, struct pinctrl_state *state)
{
	struct pinctrl_setting *setting, *setting2;
	struct pinctrl_state *old_state = p->state;
	int ret;

	if (p->state == state)
		return 0;

	if (p->state) {
		/*
		 * For each pinmux setting in the old state, forget SW's record
		 * of mux owner for that pingroup. Any pingroups which are
		 * still owned by the new state will be re-acquired by the call
		 * to pinmux_enable_setting() in the loop below.
		 */
		list_for_each_entry(setting, &p->state->settings, node) {
			if (setting->type != PIN_MAP_TYPE_MUX_GROUP)
				continue;
			pinmux_disable_setting(setting);
		}
	}

	p->state = NULL;

	/* Apply all the settings for the new state */
	list_for_each_entry(setting, &state->settings, node) {
		switch (setting->type) {
		case PIN_MAP_TYPE_MUX_GROUP:
			ret = pinmux_enable_setting(setting);
			break;
		case PIN_MAP_TYPE_CONFIGS_PIN:
		case PIN_MAP_TYPE_CONFIGS_GROUP:
			ret = pinconf_apply_setting(setting);
			break;
		default:
			ret = -EINVAL;
			break;
		}

		if (ret < 0) {
			goto unapply_new_state;
		}
	}

	p->state = state;

	return 0;
  • 코드 라인 12~13에서 인자로 전달 받은 state가 이미 선택된 경우 아무런 적용 없이 성공리에 함수를 빠져나온다.
  • 코드 라인 15~27에서 기존 state 명으로 적용된 pinmux setting들을 HW에 disable한다.
  • 코드 라인 29에서 임시로 state를 null로 대입한다.
  • 코드 라인 32~49에서 새로운 state 명으로 pinmux/pinconf setting들을 HW에 적용한다.
  • 코드 라인 51~53에서 새 state를 대입하고 성공 결과로 리턴한다.

 

drivers/pinctrl/core.c – 2/2

unapply_new_state:
	dev_err(p->dev, "Error applying setting, reverse things back\n");

	list_for_each_entry(setting2, &state->settings, node) {
		if (&setting2->node == &setting->node)
			break;
		/*
		 * All we can do here is pinmux_disable_setting.
		 * That means that some pins are muxed differently now
		 * than they were before applying the setting (We can't
		 * "unmux a pin"!), but it's not a big deal since the pins
		 * are free to be muxed by another apply_setting.
		 */
		if (setting2->type == PIN_MAP_TYPE_MUX_GROUP)
			pinmux_disable_setting(setting2);
	}

	/* There's no infinite recursive loop here because p->state is NULL */
	if (old_state)
		pinctrl_select_state(p, old_state);

	return ret;
}
EXPORT_SYMBOL_GPL(pinctrl_select_state);

새 상태를 적용하다 에러가 난 경우 모두 취소한다.

 

Pinmux HW 설정

pinmux_enable_setting()

pin controller 디바이스 드라이버를 통해 pinmux 설정이 HW에 적용되도록 요청한다.

drivers/pinctrl/pinmux.c

int pinmux_enable_setting(struct pinctrl_setting const *setting)
{
        struct pinctrl_dev *pctldev = setting->pctldev;
        const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
        const struct pinmux_ops *ops = pctldev->desc->pmxops;
        int ret = 0;
        const unsigned *pins = NULL;
        unsigned num_pins = 0;
        int i;
        struct pin_desc *desc;

        if (pctlops->get_group_pins)
                ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
                                              &pins, &num_pins);

        if (ret) {
                const char *gname;

                /* errors only affect debug data, so just warn */
                gname = pctlops->get_group_name(pctldev,
                                                setting->data.mux.group);
                dev_warn(pctldev->dev,
                         "could not get pins for group %s\n",
                         gname);
                num_pins = 0;
        }

        /* Try to allocate all pins in this group, one by one */
        for (i = 0; i < num_pins; i++) {
                ret = pin_request(pctldev, pins[i], setting->dev_name, NULL);
                if (ret) {
                        const char *gname;
                        const char *pname;

                        desc = pin_desc_get(pctldev, pins[i]);
                        pname = desc ? desc->name : "non-existing";
                        gname = pctlops->get_group_name(pctldev,
                                                setting->data.mux.group);
                        dev_err(pctldev->dev,
                                "could not request pin %d (%s) from group %s "
                                " on device %s\n",
                                pins[i], pname, gname,
                                pinctrl_dev_get_name(pctldev));
                        goto err_pin_request;
                }
        }
  • 코드 라인 12~14에서 pinmux setting의 group 인덱스에 해당하는 핀들 번로를 알아온다. 알아온 핀들 번호를 pins 변수에, 그리고 핀 개수를 num_pins에 대입한다.
    • ns2의 경우 pin control 디바이스 드라이버의 pinctrl 오퍼레이션에서 (*get_group_pins) 후크 함수를 호출하면 ns2_get_group_pins() 함수를 호출하게 된다.
    • ns2 예) “uart0_modem_grp” 그룹을 의미하는 21번 인덱스가 주어지면 -> pins = {  39, 40, 41, 42 }, num_pins = 4 가 결과로 주어진다.
  • 코드 라인 16~26에서 핀 컨트롤러 드라이버에서 그룹 인덱스로 pin 번호들을 알아오지 못하면 그룹 명을 알아와서 경고 메시지를 출력한다.
    • ns2의 경우 pin control 디바이스 드라이버의 pinctrl 오퍼레이션에서 (*get_group_name) 후크 함수를 호출하면 ns2_get_group_name() 함수를 호출하게 된다.
    • ns2 예) 21번 인덱스가 주어지면 -> gname = “uart0_modem_grp”라는 그룹명이 결과로 주어진다.
  • 코드 라인 29~46에서 그룹에 속한 핀 개수만큼 루프를 돌며 해당 핀의 할당을 하나 하나 시도한다. 만일 요청이 실패하면 에러 메시지를 출력한 후 루프를 도는 도중 할당한 핀을 모두 해제한 후 함수를 빠져나간다.

 

        /* Now that we have acquired the pins, encode the mux setting */
        for (i = 0; i < num_pins; i++) {
                desc = pin_desc_get(pctldev, pins[i]);
                if (desc == NULL) {
                        dev_warn(pctldev->dev,
                                 "could not get pin desc for pin %d\n",
                                 pins[i]);
                        continue;
                }
                desc->mux_setting = &(setting->data.mux);
        }

        ret = ops->set_mux(pctldev, setting->data.mux.func,
                           setting->data.mux.group);

        if (ret)
                goto err_set_mux;

        return 0;

err_set_mux:
        for (i = 0; i < num_pins; i++) {
                desc = pin_desc_get(pctldev, pins[i]);
                if (desc)
                        desc->mux_setting = NULL;
        }
err_pin_request:
        /* On error release all taken pins */
        while (--i >= 0)
                pin_free(pctldev, pins[i], NULL);

        return ret;
}
  • 코드 라인 2~11에서 그룹에 속한 핀 개수만큼 루프를 돌며 핀 디스크립터를 알아온 후 디스크립터의 mux_setting 값에 pinmux 세팅을 대입한다.
    • desc->mux_setting이 pinctrl_setting_mux 구조체를 가리키게 된다.
  • 코드 라인 13~17에서 group에 속한 핀들에 function을 선택하도록 H/W pin multiplexing을 요청한다.
    • ns2의 경우 pin controller 디바이스 드라이버의 pinmux 오퍼레이션의 (*set_mux) 후크 함수를 호출하면 ns2_pinmux_enable() 함수가 호출된다.

 

Pinconf HW 설정

pinconf_apply_setting()

drivers/pinctrl/pinconf.c

int pinconf_apply_setting(struct pinctrl_setting const *setting)
{                       
        struct pinctrl_dev *pctldev = setting->pctldev;
        const struct pinconf_ops *ops = pctldev->desc->confops;
        int ret;        
                        
        if (!ops) {
                dev_err(pctldev->dev, "missing confops\n");
                return -EINVAL;
        }

        switch (setting->type) {
        case PIN_MAP_TYPE_CONFIGS_PIN:
                if (!ops->pin_config_set) {
                        dev_err(pctldev->dev, "missing pin_config_set op\n");
                        return -EINVAL;
                }
                ret = ops->pin_config_set(pctldev,
                                setting->data.configs.group_or_pin,
                                setting->data.configs.configs,
                                setting->data.configs.num_configs);
                if (ret < 0) {
                        dev_err(pctldev->dev,
                                "pin_config_set op failed for pin %d\n",
                                setting->data.configs.group_or_pin);
                        return ret;
                }
                break;
        case PIN_MAP_TYPE_CONFIGS_GROUP:
                if (!ops->pin_config_group_set) {
                        dev_err(pctldev->dev,
                                "missing pin_config_group_set op\n");
                        return -EINVAL;
                }
                ret = ops->pin_config_group_set(pctldev,
                                setting->data.configs.group_or_pin,
                                setting->data.configs.configs,
                                setting->data.configs.num_configs);
                if (ret < 0) {
                        dev_err(pctldev->dev,
                                "pin_config_group_set op failed for group %d\n",
                                setting->data.configs.group_or_pin);
                        return ret;
                }
                break;
        default:
                return -EINVAL;
        }

        return 0;
}

pin controller 디바이스 드라이버를 통해 pinconf 설정이 HW에 적용되도록 요청한다.

  • 코드 라인 3~10에서 pin controller 디바이스 드라이버의 pinconf 오퍼레이션이 준비되지 않은 경우 에러 메시지를 출력하고 에러 결과로 함수를 그냥 빠져나간다.
  • 코드라인 12~28에서 핀 인덱스에 해당하는 핀을 찾아 주어진 pinconf setting들을 H/W에 적용하게 한다.
    • ns2의 경우 pin control 디바이스 드라이버의 pinconf 오퍼레이션에서 (*pin_config_set) 후크 함수를 호출하면 ns2_pin_config_set() 함수를 호출하게 된다.
    • ns2 예) “uart3_sin” 핀을 의미하는 67번 인덱스와 0x0103 setting이 주어지면 해당 번호의 핀에 pinconf HW 설정 중 하나인 bias-pull-up 설정이된다.
  • 코드라인 29~45에서 그룹 인덱스에 해당하는 핀들을 대상으로 주어진 pinconf setting들을 H/W에 적용하게 한다.
    • ns2의 경우 pin control 디바이스 드라이버의 pinconf 오퍼레이션에서 (*pin_config_group_set) 후크 함수가 없으므로 에러 메시지가 출력되고 함수를 빠져나간다.
    • 즉, ns2의 경우 그룹을 대상으로 pinconf 설정을 하지 못한다.

 

참고

 

답글 남기기

이메일은 공개되지 않습니다. 필수 입력창은 * 로 표시되어 있습니다