Pin Control Subsystem -1-

Pin Control은 각 벤더들의 독자적인 방법으로 pin 컨트롤러(H/W)를 제어하였었다. 그러다 Pin Control 서브시스템이 2011년 후반 커널 v3.2에서 Linus Walleij에 의해 소개되면서 드라이버 제어 및 구현이 표준화되었다. 디바이스 트리를 사용한 드라이버를 통해 더 간단히 설정이 가능해졌다. (샘플 코드들은 커널 v4.14 기준)

 

pin control subsystem을 통해 레지스터들을 조작하여 각 핀의 멀티플렉싱 및 속성을 설정할 수 있다.

  • 핀 멀티플렉싱(PINMUX)
  • 핀 속성 설정(PINCONF)
    • 바이어스 조정(pull down, pull up, open drain)
    • 부하 조정
    • 드라이브 강도(strength)

 

SoC에서 사용되는 수백개의 핀(Pin)들

많은 임베디드 SoC 칩은 다양한 기능들을 한 개의 칩에 포함시켜 제공한다. 먼저 SoC H/W 구조 및 기능들을 Boradcom사의 BCM6862X 칩을 예로 알아본다. 이 칩은 최신 arm64를 사용하는 상용 cpu이며, 제공하는 내부 기능은 다음과 같다. (Northstar 2라는 이름을 사용하며 줄여서 ns2이다.)

  • ARM Cortex-A57(arm64) 2 Ghz x 4 CPU core
  • DDR3 및 DDR4용Memory Controller
  • 내장 SRAM 1M
  • NAND/NOR Flash Controller
  • eMMC Controller
  • 버스: SATA 3 x 2, PCIe Gen2 4 lane x 2, USB3 x 2, USB2 x 1
  • 네트워크 Controller
  • 네트워크 Accelation을 목적으로 사용하는 추가 ARM Cortex R7 700Mhz x 2 core
  • 10G x 2, 2.5G x 2, 1G x 1 이더넷 MAC
  • Security 목적의 Secure Boot, TrustZone, …
  • 그 외 다양한 표준 입출력 장치들

 

아래 그림은 위의 칩이 가지고 있는 기능들을 블록도로 표현하였다.

주의: Broadcom 사의 데이터 시트에 나오는 정보들 중 이미 어느 정도 알려진 public한 정보들만을 일부 발췌하여 설명하기 위한 자료로 사용한다. 그러나 저작권상 보호를 받는 이미지들이므로 일부를 가려 사용하였고, 이 들을 복사하여 사용하지 않도록 주의해야 한다.

 

위에서 보여준 그림과 같이 SoC 내부에 있는 다양한 기능들을 SoC 외부에 있는 회로와 연결하기 위해 많은 핀(pin)들이 사용된다. (아래 그림은 특정 칩을 지칭하지 않음)

 

대부분의 임베디드 SoC(System On a Chip)는 수백개의 핀(pin)들을 사용한다. 이 핀들은 한 가지 기능을 위해 사용되는 것들도 있지만, 여러 가지 기능이 한 개의 핀(pin)에 선택적으로 제공되기도 하는데 바로 아래 그림 파란 박스의 기능들이 MFIO(Multi Function I/O) 핀(pin)에 연결된 기능들이다. 업체마다 다양한 표현을 사용한다. (Pin Multiplexing 또는 Pin Mux라고도 한다.)

 

Pin 디스크립터

아래 그림은 SoC에서 사용하는 핀(pin)들 중 일부(좌측 하단) 1/4 만을 보여준다. 노란색 박스로 되어있는 핀들이 MFIO(Multi Function I/O)에 사용되는 핀들이다. W열의 4번째 위치한 박스가 MFIO16이라는 핀 명칭을 가진 것을 확인할 수 있을 것이다.

 

 

이 칩이 제공하는 MFIO 핀들은 아래 표와 같이 총 63개이다. 아래 표에서 Signal이 각 핀의 이름을 의미하며 Ball은 물리적 핀 배치를 의미한다. 예를 들어 MFIO00 핀은 AP열의 2번째에 위치한다.

 

대부분의 pinctrl 드라이버들은 모든 핀에 명칭을 붙여 준비하지 않고, 기능을 선택하여 사용하는 MFIO(Multi Function I/O) 핀에 대해서만 준비하여 사용한다. 벤더들이 pinctrl 드라이버를 제공하기 위해 PIN에 명칭을 부여할 때 다음과 같은 pinctrl_pin_desc 구조체를 사용한다. number에 0번부터 시작하는 순번이 들어가며, name 필드에는 핀 명이 대입된다.

include/linux/pinctrl/pinctrl.h

/**
 * struct pinctrl_pin_desc - boards/machines provide information on their
 * pins, pads or other muxable units in this struct
 * @number: unique pin number from the global pin number space
 * @name: a name for this pin
 * @drv_data: driver-defined per-pin data. pinctrl core does not touch this
 */
struct pinctrl_pin_desc {
        unsigned number;
        const char *name;
        void *drv_data;
};

Generic 사용 예)

핀들이 복수개이므로 구조체를 보통 컴파일 타임에 배열로 생성하는데 이를 편하게 지정하기 위해 PINCTRL_PIN() 매크로를 사용하여 지정한다. 다음 예에서는 pin 명칭에 XY좌표를 사용하여 간단히 주어진 것을 보여준다.

/* Convenience macro to define a single named or anonymous pin descriptor */
#define PINCTRL_PIN(a, b) { .number = a, .name = b 

const struct pinctrl_pin_desc foo_pins[] = {
      PINCTRL_PIN(0, "A8"),
      PINCTRL_PIN(1, "B8"),
      ...
      PINCTRL_PIN(63, "H1"),
};

 

Broadcom rpi2 소스 코드 사용 예

다음 rpi2 드라이버에서 핀 명칭을 지정하는 방식을 알아보자. 핀 명칭을 간단히 gpio0 ~ gpio53까지 부여한 것을 볼 수 있다.

drivers/pinctrl/bcm/pinctrl-bcm2835.c

/* pins are just named GPIO0..GPIO53 */
#define BCM2835_GPIO_PIN(a) PINCTRL_PIN(a, "gpio" #a)
static struct pinctrl_pin_desc bcm2835_gpio_pins[] = {
        BCM2835_GPIO_PIN(0),
        BCM2835_GPIO_PIN(1),
        BCM2835_GPIO_PIN(2),
        ...
        BCM2835_GPIO_PIN(53),
}

 

Broadcom ns2 소스 코드 사용 예

다음 ns2 드라이버에서 핀 명칭을 약간 변형하여 지정하는 방식을 알아보자. pinctrl_pin_desc 구조체를 직접 사용하거나 PINCTRL_PIN() 매크로를 사용하지 않고, 벤더가 선언한 구조체를 사용하여 그냥 정의한 것을 볼 수 있다. 참고로 일부 벤더들은 PINCTRL_PIN() 매크로를 사용하지 않고, foo_PINCTRL_PIN() 매크로 또는 foo_PIN_DESC() 매크로를 별도로 정의하여 사용하기도한다.

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

/*
 * Description of a pin in Northstar2
 *
 * @pin: pin number
 * @name: pin name
 * @pin_conf: pin configuration structure
 */
struct ns2_pin {
        unsigned int pin;
        char *name;
        struct ns2_pinconf pin_conf;
};

#define NS2_PIN_DESC(p, n, b, o, s, i, pu, d)   \
{                                               \
        .pin = p,                               \
        .name = n,                              \
        .pin_conf = {                           \
                .base = b,                      \
                .offset = o,                    \
                .src_shift = s,                 \
                .input_en = i,                  \
                .pull_shift = pu,               \
                .drive_shift = d,               \
        }                                       \
}

/*
 * List of pins in Northstar2
 */
static struct ns2_pin ns2_pins[] = {
        NS2_PIN_DESC(0, "mfio_0", -1, 0, 0, 0, 0, 0),
        NS2_PIN_DESC(1, "mfio_1", -1, 0, 0, 0, 0, 0),
        NS2_PIN_DESC(2, "mfio_2", -1, 0, 0, 0, 0, 0),
        NS2_PIN_DESC(3, "mfio_3", -1, 0, 0, 0, 0, 0),
        ...
        NS2_PIN_DESC(116, "usb2_overcurrent", 2, 0x38, 7, 6, 3, 0),
        NS2_PIN_DESC(117, "sata_led1", 2, 0x3c, 15, 14, 11, 8),
        NS2_PIN_DESC(118, "sata_led0", 2, 0x3c, 7, 6, 3, 0),
};

NS2_PIN_DESC() 매크로를 보면 pin 디스크립터에 pin configuration(pinconf)에서 사용할 정보까지 담아 놓았음을 확인할 수 있다.

 

pinctrl_pin_desc 구조체 및 PINCTRL_PIN() 매크로를 사용하지 않고 임시로 구성한 핀 정보들은 probe 시에 호출되는  foo_probe() 함수에서 pinctrl_pin_desc 구조체 배열을 동적으로 할당 한 후 이 곳에 핀 정보를 복사하여 구성하는 방식을 사용한다. 다음 ns2의 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;
        ...
        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->pctl = pinctrl_register(&ns2_pinctrl_desc, &pdev->dev, pinctrl);
        ...

 

 

PIN 멀티플렉싱 (pinmux)

이렇게 여러 가지 기능을 하나의 pin에 제공하면 SoC 설계 시 핀 수를 줄여 핀이 차지하는 공간을 줄일 수 있는 장점이 있다. 사용자는 회로 설계 시 필요한 기능을 골라서 선택하여 사용할 수 있다. 한 개의 핀에 연결된 기능들은 한 가지만을 선택하여 사용하여야 하고 동시에 사용할 수 없는 단점이 있다. 다음 그림을 보면 NOR Flash 기능과 Nand Flash 기능을 사용할 때 각 기능에 대해 많은 핀들이 사용된다. 최근에는 NOR Flash와 Nand Flash를 동시에 제공하지 않고 선택 적용하는 케이스들이 많이 있다. 이러한 시스템에서 핀을 선택하기 위해 사용하는 방법이 PIN 멀티 플렉싱을 사용한다. 아래 MFIO(Multi Function I/O) 0번 핀에 두 가지 기능이 선택될 수 있는 것을 알 수 있다.

 

다음 표는 MFIO 각 핀들이 사용할 수 있는 기능들을 보여준다. 예를 들어 MFIO 37번 핀은 3가지의 기능을 사용할 수 있고, 각각 GPIO 12번, PCIE A버스의 2번째 lane 또는 Nor 플래시 중 하나에 사용될 수 있다. 즉 H/W 설계 시 PCIe A버스의 2번째 lane을 사용하여야 하는 경우 GPIO의 12번~13번 핀 및 Nor 플래시 등을 이용할 수 없게됨을 알 수 있다.

 

다음 그림은 위의 표를 참조하여 MFIO37번 핀에 연결된 3개의 기능들이 연결되어 있는 모습을 보여준다.

 

이어서 MFIO37번과 MFIO38번이 PCIe 디바이스에 연결된 모습을 보여준다. 이 경우 GPIO_12번과 GPIO_13번 및 NOR 플래시 디바이스를 연결하여 사용할 수 없다.

 

pinmux 설정

pinmux를 통해 function을 설정하는 방법은 다음과 같은 방법들이 있다.

 

SoC 내부 디폴트 설정

MFIO 핀을 어떠한 용도로 사용할지는 SoC가 각 MFIO 핀 별로 부트업시 default 설정이 지정된다. 물론 각 제조사의 칩 데이터 시트를 참고해야 한다

 

부트 스트랩에 의한 설정

H/W 설계 시 bootstrap 설정에 의해 모드가 지정되는 MFIO 핀들도 있다. 이 경우에는 각 제조사의 데이터 시트를 참고하여 처음 모드가 어떻게 되는지 알아볼 수 있다.

 

S/W 설정

pin control 드라이버를 통해 커널 부트업시 각 MFIO 핀의 모드를 mux 레지스터의 조작을 통해 설정할 수 있다. 최근 커널은 당연히 디바이스 트리를 읽어서 자동으로 설정한다. 부트 후에도 커널에서는 pinctrl에 대한 kernel API를 사용하여 pinmux  및 pinconf 설정이 가능하다. 또한 유저 스페이스에서도 모드를 바꿀 수 있는 시스템 파일 경로를 제공한다.

  • 디바이스 트리를 사용하기 전에는 각 아키텍처로 만들어진 머신(보드)에 대한 초기화 코드에 pinmux 및 pinconf에 대한 설정을 해왔다.
  • 디바이스 트리를 사용하면서부터(64비트 디폴트) 디바이스 트리에서 pinmux 및 pinconf에 대한 설정을 할 수 있게 되었다.

 

Pin Configuration (pinconf)

pin configuration은 대부분 GPIO 서브시스템과 같이 사용된다. GPIO를 사용할 때 pinmux로 선택하는지 아니면 항상 동작하는지에 따라 두 가지 유형으로 나뉜다.

  • case A)와 같은 경우 GPIO를 사용하려면 pinmux에 선택되어 사용되어야 한다. 대부분의 경우 pinmux에서 GPIO는 디폴트로 선택되어 있다.
  • case B)와 같은 경우 GPIO가 항상 동작 가능한 상태이다. 뒷 부분에 있는 pinmux에 의해 특정 장치가 선택되어 사용될 때 동시에 연결되어 사용되고 있는 GPIO가 방해를 하지 않도록 조심해야 한다.

 

아래 그림은 rpi2의 gpio 핀 하나를 대략적으로 보여준다. 여기에서 pad의 위치를 확인해본다.

  • 가장 상위의 삼각형 모습이 pad가 출력 모드로 설정되는 경우 동작하는 회로이다.
  • 그다음 삼각형 모습은 pad가 입력 모드로 설정되는 경우 동작하는 회로이다.
  • 아래 MOS-FET가 있는 곳은 pad에 pull-up 및 pull-down 바이어스를 연결하기 위한 회로이다.

다음에서 설정할 수 있는 속성들을 알아보자. 물론 H/W마다 지원하는 속성이 있다. 각각의 속성 지원 여부는 칩제조사의 데이터시트를 확인해야한다. 기존 칩 제조사의 pin controller의 확인은 Document/devicetree/binding/pinctrl 디렉토리에서 확인할 수 있다.

출력 관련
  • output-low
    • 로우 레벨 출력 모드로 설정한다.
  • output-high
    • 하이 레벨 출력 모드로 설정한다.
  •  drive-push-pull
    • 출력을 push & pull 모드로 설정한다.
  • drive-open-drain
    • 출력을 open drain 모드로 설정한다.
  • drive-open-source
    • 출력을 open source 모드로 설정한다.
  • drive-strength
    • 드라이브 출력을 X mA로 설정한다.

 

입력 관련
  • bias-pull-down
    • 입력 핀에 pull-down 바이어스 전류를 공급한다.
  • bias-pull-up
    • 입력 핀에 pull-up 바이어스 전류를 공급한다.
  • bias-high-impedance
    • pull-up도 아니고 pull-down도 아닌 중간 high-impedance 상태가 유지되도록 입력 핀에 바이어스를 공급한다.
  • bias-bus-hold
    • 핀에 입력된 시그널 상태를 기억하여 다음 신호 입력 전까지 기존 상태를 유지한다.
    • 래치와 같이 동작하도록 입력 핀에 약한 피드백 전류를 공급하여 상태를 유지하게 한다.
  •  bias-disable
    • 핀에 바이어스 전류를 공급하지 않는다.
  • bias-pull-pin-default
    • 핀에 디폴트 상태의 바이어스 전류를 공급한다.
  •  input-enable
    • 입력 핀을 enable 한다.
    • 출력 모드일 때에는 영향이 없다
  •  input-schmitt-enable
    • schmitt 트리거 모드를 enable한다.
  •  input-schmitt-disable
    • schmitt 트리거 모드를 disable한다.
  •  input-debounce
    • 디바운스 모드로 동작시키고 디바운스 타임 X를 설정한다.

 

기타
  • power-source
    • 다른 파워 공급(서플라이)을 선택할 수 있다.
  • low-power-enable
    • 저 전력 모드를 enable 한다.
  • low-power-disable
    • 저 전력 모드를 disable 한다.

 

다음 그림에서 보여주는 바이어스 전류 공급 방법이 가장 많이 사용하는 방법들이다.

 

Pin Control 드라이버 구조

 

아래의 그림은 pin control 드라이버와 관련된 구조를 보여준다.

  • 우측 파란 박스가 pinctrl 드라이버 구현부분이다.
  • Pinctrl 서브시스템 코어는 각 클라이언트 디바이스 드라이버 내부에서 API로 요청하는 pinmux/pinconf 설정을 받아들인다.
  • 좌측 아래 회색 박스의 디바이스 트리를 보면 부트업 타임에 pinmux 및 pinconf에 대한 state 매핑을 등록한다.

 

GPIO 드라이버와의 연계

최근의 SoC는 MFIO와 GPIO 기능이 동시에 제공되므로 이러한 기능을 한 개의 드라이버에서 구현하여 제공하기도 한다.

  • 특정 장치들은 pin controller가 사용하는 모든 pin이 gpio와 1:1로 구성되는 경우도 있다. (예: rpi2)

 

Interrupt Controller 드라이버와의 연계

또한 GPIO 내부에 일부 입력핀들이 외부 인터럽터를 수신할 수 있도록 구성된 Interrupt 멀티플렉서 장치들도 많이 구성된다. 따라서 최근에는 Pin Controller + GPIO Controller + Interrupt Controller가 동시에 제공되는 드라이버를 구성하기도 한다. (예: rpi2, exynos, omap, dra7, am437, sunxi, …)

 

pinctrl 드라이버를 작성할 때 pinctrl 디스크립터를 통해 3개의 오퍼레이션을 구현하고, 추가로 GPIO Controller 및 Interrupt Controller도 여러 가지 구현 경우에 따라 추가될 수 있음을 알 수 있다.

 

Pin Controller

pin controller 디바이스 드라이버는 다음과 같이 3개의 오퍼레이션으로 구현된다.

 

디바이스 드라이버의 pinmux/pinconf 요청

커널 부트업시 디바이스 트리로 구성되어 가동되는 여러 기능의 드라이버들 중 일부가 MFIO핀을 이용하는 경우 pinmux와 같이 자신의 기능을 선택하기위해 요청하는 기능이 있다. 또한 핀의 모드를 설정하기 위해 pinconf 요청을 할 수도 있다.

 

 

pinctrl 디스크립터

pinctrl 디스크립터의 정의는 다음과 같이 pinctrl_desc 구조체를 사용하여 정의된다. pin 디스크립터에서 정의한 pin들을 지정하고 있고, 이 핀들을 대상으로 pinctrl 서브시스템용 API가 구현될 수 있도록 3가지의 operation 구조체 후크를 사용한다. 3가지의 오퍼레이션은 다음의 기능을 지원한다.

  • pinctrl_ops
    • 핀 그룹에 소속된 핀들 정보를 제공한다.
  • pinmux_ops
    • 핀에 연결된 기능을 선택한다.
  • pinconf_ops
    • 핀의 속성(pull up, pull down, open drain, strength, …)을 설정한다.

 

다음 그림은 pinctrl 디스크립터와 구현해야 할 3개의 오퍼레이션들을 보여준다.

 

첫 번째 예) rpi2 드라이버

drivers/pinctrl/bcm/pinctrl-bcm2835.c

static struct pinctrl_desc bcm2835_pinctrl_desc = {
        .name = MODULE_NAME,
        .pins = bcm2835_gpio_pins,
        .npins = ARRAY_SIZE(bcm2835_gpio_pins),
        .pctlops = &bcm2835_pctl_ops,
        .pmxops = &bcm2835_pmx_ops,
        .confops = &bcm2835_pinconf_ops,
        .owner = THIS_MODULE,
};

 

두 번째 예) ns2 드라이버 – pins 필드는 probe 함수에서 동적으로 생성되는 pin 디스크립터 정보들을 대입하므로 컴파일 타임에 지정하지 않는다.

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

static struct pinctrl_desc ns2_pinctrl_desc = {
        .name = "ns2-pinmux",
        .pctlops = &ns2_pinctrl_ops,
        .pmxops = &ns2_pinmux_ops,
        .confops = &ns2_pinconf_ops,
};

 

1) Pin 그룹 (for pinctrl & pinconf)

pin control을 사용하는 기능들은 1개 이상의 핀들을 사용한다.  각 기능들이 사용하는 MFIO 핀들을 알아본다. 다음 그림에서 8 개의 핀에 대한 그룹 분류를 알아보자.

Generic 사용 예

예를 들어 UART0를 사용하기 위해서 MFIO_39 ~ MFIO_46번까지 8개의 핀이 사용되고, 이를 용도별로 3개의 그룹으로 나누어 표현하면 다음과 같다.

static const unsigned int uart0_modem_pins[] = {39, 40, 41, 42};
static const unsigned int uart0_rts_cts_pins[] = {43, 44};
static const unsigned int uart0_in_out_pins[] = {45, 46};

 

GPIO는 MFIO_24 ~ MFIO_25, MFIO_27 ~ MFIO_56번까지의 32개의 핀이 사용되는데, UART0와 중복되어 사용되는 핀들의 그룹을 정리하면 다음과 같다.

static const unsigned int gpio_14_17_pins[] = {39, 40, 41, 42};
static const unsigned int gpio_18_19_pins[] = {43, 44};
static const unsigned int gpio_20_21_pins[] = {45, 46};

 

마지막으로 NOR 플래시는 MFIO_0 ~ MFIO_42번까지 43개의 핀이 사용되는데, UART0와 중복되어 사용되는 핀 그룹은 다음과 같다.

static const unsigned int nor_addr_12_15_pins[] = {39, 40, 41, 42};

 

핀 그룹들을 관리하는 방법들은 드라이버 개발자마다 조금씩 다르게 구현하지만 기본 형태는 다음과 같다. 다음 코드에서 8개의 MFIO_39 ~ MFIO_46 핀들에 대한 그룹들의 분류를 알아본다.

#include <linux/pinctrl/pinctrl.h>
struct foo_group {
	const char *name;
	const unsigned int *pins;
	const unsigned num_pins;
};

static const struct foo_group foo_groups[] = {
        ...
	{
		.name = "gpio_14_17_grp",
		.pins = gpio_14_17_pins,
		.num_pins = ARRAY_SIZE(gpio_14_17_pins),
	},
	{
		.name = "uart0_modem_grp",
		.pins = uart0_modem_pins,
		.num_pins = ARRAY_SIZE(uart0_modem_pins),
	},
        { 
                .name = "nor_addr_12_15_grp", 
                .pins = nor_addr_12_15_pins, 
                .num_pins = ARRAY_SIZE(nor_addr_12_15_pins), 
        }, 
	{
		.name = "gpio_18_19_grp",
		.pins = gpio_18_19_pins,
		.num_pins = ARRAY_SIZE(gpio_18_19_pins),
	},
	{
		.name = "uart0_rts_cts_grp",
		.pins = uart0_rts_cts_pins,
		.num_pins = ARRAY_SIZE(uart0_rts_cts_pins),
	},
	{
		.name = "gpio_20_21_grp",
		.pins = gpio_20_21_pins,
		.num_pins = ARRAY_SIZE(gpio_20_21_pins),
	},
	{
		.name = "uart0_in_out_grp",
		.pins = uart0_in_out_pins,
		.num_pins = ARRAY_SIZE(uart0_in_out_pins),
	},

        ...
};

 

Broadcom ns2 소스 코드 사용 예

다음은 8개의 MFIO_39_46 핀들에 대한 broadcom ns2의 실제 소스 코드이다.

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

/*
 * Group based IOMUX configuration
 *
 * @name: name of the group
 * @pins: array of pins used by this group
 * @num_pins: total number of pins used by this group
 * @mux: Northstar2 group based IOMUX configuration
 */
struct ns2_pin_group {
        const char *name;
        const unsigned int *pins;
        const unsigned int num_pins;
        const struct ns2_mux mux;
};

generic한 foo_group 구조체 형태에서  ns2_mux 구조체가 하나 더 추가되었다.

 

/*
 * Northstar2 IOMUX register description
 *
 * @base: base address number
 * @offset: register offset for mux configuration of a group
 * @shift: bit shift for mux configuration of a group
 * @mask: mask bits
 * @alt: alternate function to set to
 */
struct ns2_mux {
        unsigned int base;
        unsigned int offset;
        unsigned int shift;
        unsigned int mask;
        unsigned int alt;
};

generic foo_group 구조체 형태에 function을 선택하기 위한 Mux 레지스터 주소 및 컨트롤 정보등을 추가하기 위해 ns2_mux 구조체를 사용하였다.

 

#define NS2_PIN_GROUP(group_name, ba, off, sh, ma, al)  \
{                                                       \
        .name = __stringify(group_name) "_grp",         \
        .pins = group_name ## _pins,                    \
        .num_pins = ARRAY_SIZE(group_name ## _pins),    \
        .mux = {                                        \
                .base = ba,                             \
                .offset = off,                          \
                .shift = sh,                            \
                .mask = ma,                             \
                .alt = al,                              \
        }                                               \
}


/*
 * List of Northstar2 pin groups
 */
static const struct ns2_pin_group ns2_pin_groups[] = {
	...
        NS2_PIN_GROUP(gpio_14_17, 0, 4, 18, 3, 0),
        NS2_PIN_GROUP(uart0_modem, 0, 4, 18, 3, 1),
        NS2_PIN_GROUP(nor_addr_12_15, 0, 4, 18, 3, 2),

        NS2_PIN_GROUP(gpio_18_19, 0, 4, 16, 3, 0),
        NS2_PIN_GROUP(uart0_rts_cts, 0, 4, 16, 3, 1),

        NS2_PIN_GROUP(gpio_20_21, 0, 4, 14, 3, 0),
        NS2_PIN_GROUP(uart0_in_out, 0, 4, 14, 3, 1),
	...
};

generic foo_groups[] 배열 을 구성하는데 <name>_grp, <name>_pins, 핀 수 및 mux 정보(base, offset, shift, mask, alt) 등을 컴파일 타임에 정의한다.

 

Pin 그룹 오퍼레이션 구현

정의된 핀 그룹에 대한 조회등을 할 수 있는 pinctrl 오퍼레이션을 구현하는 방법을 알아보자.

 

Generic 사용 예

static int foo_get_groups_count(struct pinctrl_dev *pctldev)
{
	return ARRAY_SIZE(foo_groups);
}

static const char *foo_get_group_name(struct pinctrl_dev *pctldev,
				       unsigned selector)
{
	return foo_groups[selector].name;
}

static int foo_get_group_pins(struct pinctrl_dev *pctldev, unsigned selector,
			       const unsigned **pins,
			       unsigned *num_pins)
{
	*pins = (unsigned *) foo_groups[selector].pins;
	*num_pins = foo_groups[selector].num_pins;
	return 0;
}

static struct pinctrl_ops foo_pctrl_ops = {
	.get_groups_count = foo_get_groups_count,
	.get_group_name = foo_get_group_name,
	.get_group_pins = foo_get_group_pins,
};

static struct pinctrl_desc foo_desc = {
       ...
       .pctlops = &foo_pctrl_ops,
};

핀 디스크립터에는 3가지의 operations가 지정되는데 첫 번째로 핀 컨트롤러의 핀 그룹 정보를 담당하는 pctlops에 해당하는 operation에 다음 3개의 함수를 구현한다.

  • (*get_groups_count)
    • 등록된 그룹들의 수를 반환한다.
  • (*get_group_name)
    • selector를 인덱스로 그룹명을 반환한다.
  • (*get_group_pins)
    • selector를 인덱스로 그룹을 찾아 출력 인수 pins에 핀 목록. 그리고 출력 인수 num_pins에 핀 수를 반환한다.
    • 예) selector=0 (gpio_pin_14_17을 찾은 것으로 하자)
      • -> pin={ 14, 15, 16, 17 }, num_pins=4

 

Broadcom ns2 소스 코드 사용 예

다음 코드는 broadcom ns2의 실제 소스 코드이다.

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

static int ns2_get_groups_count(struct pinctrl_dev *pctrl_dev)
{
        struct ns2_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctrl_dev);

        return pinctrl->num_groups;
}

static const char *ns2_get_group_name(struct pinctrl_dev *pctrl_dev,
                                      unsigned int selector)
{
        struct ns2_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctrl_dev);

        return pinctrl->groups[selector].name;
}

static int ns2_get_group_pins(struct pinctrl_dev *pctrl_dev,
                              unsigned int selector, const unsigned int **pins,
                              unsigned int *num_pins)
{
        struct ns2_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctrl_dev);

        *pins = pinctrl->groups[selector].pins;
        *num_pins = pinctrl->groups[selector].num_pins;

        return 0;
}

static void ns2_pin_dbg_show(struct pinctrl_dev *pctrl_dev,
                             struct seq_file *s, unsigned int offset)
{
        seq_printf(s, " %s", dev_name(pctrl_dev->dev));
}

static const struct pinctrl_ops ns2_pinctrl_ops = {
        .get_groups_count = ns2_get_groups_count,
        .get_group_name = ns2_get_group_name,
        .get_group_pins = ns2_get_group_pins,
        .pin_dbg_show = ns2_pin_dbg_show,
        .dt_node_to_map = pinconf_generic_dt_node_to_map_pin,
        .dt_free_map = pinctrl_utils_free_map,
};

static struct pinctrl_desc ns2_pinctrl_desc = {
        .name = "ns2-pinmux",
        .pctlops = &ns2_pinctrl_ops,
        ...
};

generic 사용 예보다 3개의 함수가 추가로 구현되어 있음을 알 수 있다.

  • (*pin_dbg_show)
    • debugfs(CONFIG_DEBUG_FS 커널 옵션 사용)를 사용하는 경우 pin control subsystem core를 통하여 pin 정보를 출력할 수 있다.
    • 예) $ cat /sys/kernel/debug/pins
    • 호출 경로:
      • &pinctrl_pins_ops.(*open) ->
      • pinctrl_pins_open() ->
      • single_open(file, pinctrl_pins_show, …) ->
      • pinctrl_pins_show() ->
      • pctldev->desc->pctlops->(*pin_dbg_show)
  • (*dt_node_to_map)
    • 디바이스 트리를 통해서 그룹에 pinmux, 또는 핀/그룹에 pinconf 설정을 하도록 매핑한다.
    • 호출 경로:
      • pinctrl_register() ->
      • pinctrl_get() ->
      • create_pinctrl() ->
      • pinctrl_dt_to_map() ->
      • dt_to_map_one_config() ->
      • pctldev->desc->pctlops->(*dt_node_to_map)
  • (*dt_free_map)
    • 디바이스 트리를 통해서 매핑한 설정을 해제한다.
    • 호출 경로:
      • pinctrl_unregister() ->
      • pinctrl_put() ->
      • pinctrl_release() ->
      • pinctrl_free() ->
      • pinctrl_dt_free_maps() ->
      • dt_free_map() ->
      • dt_to_map_one_config() ->
      • pctldev->desc->pctlops->(*dt_node_to_map)

 

2) Pin Function (for pinmux)

그룹화된 핀들을 기능(Function)으로 묶는 것을 알아본다.

 

Generic 사용 예

예를 들어 UART0를 사용하기 위해서는 uart0_modem_grp, uart0_rts_cts_grp, uart0_in_out_grp이 필요하다. 다음 코드 예를 보고 uar0_groups가 어떻게 구성이 되었는지 확인해본다.

static const char * const gpio_groups[] = { "gpio_14_17_grp", "gpio_18_19_grp", "gpio_20_21_grp" };
static const char * const uart0_groups[] = { "uart0_modem_grp", "uart0_rts_cts_grp", "uart0_in_out_grp" };
static const char * const nor_groups[] = { "nor_addr_12_15_grp" };

static const struct foo_pmx_func foo_functions[] = {
        ...
	{
		.name = "gpio",
		.groups = gpio_groups,
		.num_groups = ARRAY_SIZE(gpio_groups),
	},
	{
		.name = "uart0",
		.groups = uart0_groups,
		.num_groups = ARRAY_SIZE(uart0_groups),
	},
	{
		.name = "nor",
		.groups = nor_groups,
		.num_groups = ARRAY_SIZE(nor_groups),
	},
        ...
};

 

Broadcom ns2 소스 코드 사용 예

다음 코드는 broadcom ns2의 실제 코드이다.

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

/*
 * List of groups supported by functions
 */

static const char * const nand_grps[] = {"nand_grp"};

static const char * const nor_grps[] = {"nor_data_grp", "nor_adv_grp",
        "nor_addr_0_3_grp", "nor_addr_4_5_grp", "nor_addr_6_7_grp",
        "nor_addr_8_9_grp", "nor_addr_10_11_grp", "nor_addr_12_15_grp"};

static const char * const gpio_grps[] = {"gpio_0_1_grp", "gpio_2_5_grp",
        "gpio_6_7_grp", "gpio_8_9_grp", "gpio_10_11_grp", "gpio_12_13_grp",
        "gpio_14_17_grp", "gpio_18_19_grp", "gpio_20_21_grp", "gpio_22_23_grp",
        "gpio_24_25_grp", "gpio_26_27_grp", "gpio_28_29_grp",
        "gpio_30_31_grp"};

static const char * const pcie_grps[] = {"pcie_ab1_clk_wak_grp",
        "pcie_a3_clk_wak_grp", "pcie_b3_clk_wak_grp", "pcie_b2_clk_wak_grp",
        "pcie_a2_clk_wak_grp"};

static const char * const uart0_grps[] = {"uart0_modem_grp",
        "uart0_rts_cts_grp", "uart0_in_out_grp"};

static const char * const uart1_grps[] = {"uart1_ext_clk_grp",
        "uart1_dcd_dsr_grp", "uart1_ri_dtr_grp", "uart1_rts_cts_grp",
        "uart1_in_out_grp"};

static const char * const uart2_grps[] = {"uart2_rts_cts_grp"};

static const char * const pwm_grps[] = {"pwm_0_grp", "pwm_1_grp",
        "pwm_2_grp", "pwm_3_grp"};

#define NS2_PIN_FUNCTION(func)                          \
{                                                       \
        .name = #func,                                  \
        .groups = func ## _grps,                        \
        .num_groups = ARRAY_SIZE(func ## _grps),        \
}

/*
 * List of supported functions
 */
static const struct ns2_pin_function ns2_pin_functions[] = {
        NS2_PIN_FUNCTION(nand),
        NS2_PIN_FUNCTION(nor),
        NS2_PIN_FUNCTION(gpio),
        NS2_PIN_FUNCTION(pcie),
        NS2_PIN_FUNCTION(uart0),
        NS2_PIN_FUNCTION(uart1),
        NS2_PIN_FUNCTION(uart2),
        NS2_PIN_FUNCTION(pwm),
};

 

 

Pin Mux 오퍼레이션 구현

 

Generic 사용 예

정의된 핀 Mux에 대한 오퍼레이션을 구현하는 방법은 다음과 같다.

static int foo_get_functions_count(struct pinctrl_dev *pctldev)
{
	return ARRAY_SIZE(foo_functions);
}

static const char *foo_get_fname(struct pinctrl_dev *pctldev, unsigned selector)
{
	return foo_functions[selector].name;
}

static int foo_get_groups(struct pinctrl_dev *pctldev, unsigned selector,
			  const char * const **groups,
			  unsigned * const num_groups)
{
	*groups = foo_functions[selector].groups;
	*num_groups = foo_functions[selector].num_groups;
	return 0;
}

static int foo_set_mux(struct pinctrl_dev *pctldev, unsigned selector,
		unsigned group)
{
	u8 regbit = (1 << selector + group);

	writeb((readb(MUX)|regbit), MUX)
	return 0;
}

static struct pinmux_ops foo_pmxops = {
	.get_functions_count = foo_get_functions_count,
	.get_function_name = foo_get_fname,
	.get_function_groups = foo_get_groups,
	.set_mux = foo_set_mux,
	.strict = true,
};

/* Pinmux operations are handled by some pin controller */
static struct pinctrl_desc foo_desc = {
	...
	.pctlops = &foo_pctrl_ops,
	.pmxops = &foo_pmxops,
};

pinmux를 동작시키는데 필요한 pinmux_ops 구조체에 사용하는 다음 함수들을 구현한다.

  • (*get_functions_count)
    • 등록된 펑션들의 수를 반환한다.
  • (*get_function_name)
    • selector를 인덱스로 펑션명을 반환한다.
  • (*get_function_groups)
    • selector를 인덱스로 펑션을 찾아 해당 펑션에 속한 그룹들 목록을 출력 인수 groups에 대입한다. 그리고 그리고 출력 인수 num_groups에는 그룹 수를 반환한다.
    • 예) selector=4 (uart0 펑션을 찾은 것으로 하자)
      • -> groups={ “uart0_modem_grp”, “uart0_rts_cts_grp”, “uart0_in_out_grp” }, num_groups=3
  • (*set_mux)
    • selector를 인덱스로 펑션을 찾고 지정한 그룹을 선택한다.
    • 예) selector=4 (uart0 펑션을 찾은 것으로 하자), group=1
      • -> pinmux 레지스터를 사용하여 “uart0” 펑션에 소속한 “uart0_rts_cts_grp” 핀들을 선택하게 한다.

 

Broadcom ns2 소스 코드 사용 예

다음 코드는 broadcom ns2의 실제 소스 코드이다.

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

static int ns2_get_functions_count(struct pinctrl_dev *pctrl_dev)
{
        struct ns2_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctrl_dev);

        return pinctrl->num_functions;
}

static const char *ns2_get_function_name(struct pinctrl_dev *pctrl_dev,
                                         unsigned int selector)
{
        struct ns2_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctrl_dev);

        return pinctrl->functions[selector].name;
}

static int ns2_get_function_groups(struct pinctrl_dev *pctrl_dev,
                                   unsigned int selector,
                                   const char * const **groups,
                                   unsigned int * const num_groups)
{
        struct ns2_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctrl_dev);

        *groups = pinctrl->functions[selector].groups;
        *num_groups = pinctrl->functions[selector].num_groups;

        return 0;
}

static int ns2_pinmux_enable(struct pinctrl_dev *pctrl_dev,
                             unsigned int func_select, unsigned int grp_select)
{
        struct ns2_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctrl_dev);
        const struct ns2_pin_function *func;
        const struct ns2_pin_group *grp;

        if (grp_select > pinctrl->num_groups ||
                func_select > pinctrl->num_functions)
                return -EINVAL;

        func = &pinctrl->functions[func_select];
        grp = &pinctrl->groups[grp_select];

        dev_dbg(pctrl_dev->dev, "func:%u name:%s grp:%u name:%s\n",
                func_select, func->name, grp_select, grp->name);

        dev_dbg(pctrl_dev->dev, "offset:0x%08x shift:%u alt:%u\n",
                grp->mux.offset, grp->mux.shift, grp->mux.alt);

        return ns2_pinmux_set(pinctrl, func, grp, pinctrl->mux_log);
}

static const struct pinmux_ops ns2_pinmux_ops = {
        .get_functions_count = ns2_get_functions_count,
        .get_function_name = ns2_get_function_name,
        .get_function_groups = ns2_get_function_groups,
        .set_mux = ns2_pinmux_enable,
};

static struct pinctrl_desc ns2_pinctrl_desc = {
        .name = "ns2-pinmux",
        .pmxops = &ns2_pinmux_ops,
        ...
};

generic 코드 예와 거의 동일하다.

 

다음 아래 코드에 있는 함수는 ns2_pinmux_enable() 함수에서 호출하여 사용하는 함수로 실제 broadcom ns2의 pin controller(MFIO 레지스터)를 이용하여 pin에 대한 function을 설정한다.

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

static int ns2_pinmux_set(struct ns2_pinctrl *pinctrl,
                          const struct ns2_pin_function *func,
                          const struct ns2_pin_group *grp,
                          struct ns2_mux_log *mux_log)
{
        const struct ns2_mux *mux = &grp->mux;
        int i;
        u32 val, mask;
        unsigned long flags;
        void __iomem *base_address;

        for (i = 0; i < NS2_NUM_IOMUX; i++) {
                if ((mux->shift != mux_log[i].mux.shift) ||
                        (mux->base != mux_log[i].mux.base) ||
                        (mux->offset != mux_log[i].mux.offset))
                        continue;

                /* if this is a new configuration, just do it! */
                if (!mux_log[i].is_configured)
                        break;

                /*
                 * IOMUX has been configured previously and one is trying to
                 * configure it to a different function
                 */
                if (mux_log[i].mux.alt != mux->alt) {
                        dev_err(pinctrl->dev,
                                "double configuration error detected!\n");
                        dev_err(pinctrl->dev, "func:%s grp:%s\n",
                                func->name, grp->name);
                        return -EINVAL;
                }

                return 0;
        }
        if (i == NS2_NUM_IOMUX)
                return -EINVAL;

        mask = mux->mask;
        mux_log[i].mux.alt = mux->alt;
        mux_log[i].is_configured = true;

        switch (mux->base) {
        case NS2_PIN_MUX_BASE0:
                base_address = pinctrl->base0;
                break;

        case NS2_PIN_MUX_BASE1:
                base_address = pinctrl->base1;
                break;

        default:
                return -EINVAL;
        }

        spin_lock_irqsave(&pinctrl->lock, flags);
        val = readl(base_address + grp->mux.offset);
        val &= ~(mask << grp->mux.shift);
        val |= grp->mux.alt << grp->mux.shift;
        writel(val, (base_address + grp->mux.offset));
        spin_unlock_irqrestore(&pinctrl->lock, flags);

        return 0;
}

ns2의 pinmux 레지스터를 사용하여 요청한 펑션 인덱스와 그룹 인덱스에 해당하는 핀에 대해  선택하게 한다. (소스 설명 생략)

 

3) Pin Configuration (for pinconf)

 

Pin Configuration 오퍼레이션 구현

핀 또는 핀 그룹에 대한 설정을 하거나 조회할 수 있도록 pinconf 오퍼레이션의 구현에 대해 알아본다.

 

Generic 사용 예

#include <linux/pinctrl/pinctrl.h>
#include <linux/pinctrl/pinconf.h>
#include "platform_x_pindefs.h"

static int foo_pin_config_get(struct pinctrl_dev *pctldev,
		    unsigned offset,
		    unsigned long *config)
{
	struct my_conftype conf;

	... Find setting for pin @ offset ...

	*config = (unsigned long) conf;
}

static int foo_pin_config_set(struct pinctrl_dev *pctldev,
		    unsigned offset,
		    unsigned long config)
{
	struct my_conftype *conf = (struct my_conftype *) config;

	switch (conf) {
		case PLATFORM_X_PULL_UP:
		...
		}
	}
}

static int foo_pin_config_group_get (struct pinctrl_dev *pctldev,
		    unsigned selector,
		    unsigned long *config)
{
	...
}

static int foo_pin_config_group_set (struct pinctrl_dev *pctldev,
		    unsigned selector,
		    unsigned long config)
{
	...
}

static struct pinconf_ops foo_pconf_ops = {
	.pin_config_get = foo_pin_config_get,
	.pin_config_set = foo_pin_config_set,
	.pin_config_group_get = foo_pin_config_group_get,
	.pin_config_group_set = foo_pin_config_group_set,
};

/* Pin config operations are handled by some pin controller */
static struct pinctrl_desc foo_desc = {
	...
	.confops = &foo_pconf_ops,
};

pinconf를 동작시키는데 필요한 pinconf_ops 구조체에 사용하는 다음 함수들을 구현한다.

  • (*pin_config_get)
    • 핀에 인자로 지정한 pinconf 설정이 있는 경우 그 값을 알아온다.
  • (*pin_config_set)
    • 핀에 pinconf 설정을 한다.
  • (*pin_config_group_get)
    • 그룹에 등록된 pinconf 설정이 있는 경우 그 값을 알아온다.
  • (*pin_config_group_set)
    • 그룹에 속한 핀들에 pinconf 설정을 한다.

 

Broadcom ns2 소스 코드 사용 예

다음 코드는 broadcom ns2의 실제 코드이다. 현재 그룹에 대한 구현은 보이지 않고 핀에 대한 구현만 있음을 알 수 있다.

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

static int ns2_pin_config_get(struct pinctrl_dev *pctldev, unsigned int pin,
                              unsigned long *config)
{
        struct ns2_pin *pin_data = pctldev->desc->pins[pin].drv_data;
        enum pin_config_param param = pinconf_to_config_param(*config);
        bool pull_up, pull_down;
        u16 arg = 0;
        int ret;

        if (pin_data->pin_conf.base == -1)
                return -ENOTSUPP;

        switch (param) {
        case PIN_CONFIG_BIAS_DISABLE:
                ns2_pin_get_pull(pctldev, pin, &pull_up, &pull_down);
                if ((pull_up == false) && (pull_down == false))
                        return 0;
                else
                        return -EINVAL;

        case PIN_CONFIG_BIAS_PULL_UP:
             ...

        case PIN_CONFIG_BIAS_PULL_DOWN:
             ...

        case PIN_CONFIG_DRIVE_STRENGTH:
             ...

        case PIN_CONFIG_SLEW_RATE:
             ...

        case PIN_CONFIG_INPUT_ENABLE:
             ...

        default:
                return -ENOTSUPP;
        }
}

static int ns2_pin_config_set(struct pinctrl_dev *pctrldev, unsigned int pin,
                              unsigned long *configs, unsigned int num_configs)
{
        struct ns2_pin *pin_data = pctrldev->desc->pins[pin].drv_data;
        enum pin_config_param param;
        unsigned int i;
        u16 arg;
        int ret = -ENOTSUPP;

        if (pin_data->pin_conf.base == -1)
                return -ENOTSUPP;

        for (i = 0; i < num_configs; i++) {
                param = pinconf_to_config_param(configs[i]);
                arg = pinconf_to_config_argument(configs[i]);

                switch (param) {
                case PIN_CONFIG_BIAS_DISABLE:
                        ret = ns2_pin_set_pull(pctrldev, pin, false, false);
                        if (ret < 0)
                                goto out;
                        break;

                case PIN_CONFIG_BIAS_PULL_UP:
                     ...

                case PIN_CONFIG_BIAS_PULL_DOWN:
                     ...

                case PIN_CONFIG_DRIVE_STRENGTH:
                     ...

                case PIN_CONFIG_SLEW_RATE:
                     ...

                case PIN_CONFIG_INPUT_ENABLE:
                     ...

                default:
                        dev_err(pctrldev->dev, "invalid configuration\n");
                        return -ENOTSUPP;
                }
        }
out:
        return ret;
}

static const struct pinconf_ops ns2_pinconf_ops = {
        .is_generic = true,
        .pin_config_get = ns2_pin_config_get,
        .pin_config_set = ns2_pin_config_set,
};

static struct pinctrl_desc ns2_pinctrl_desc = {
        .name = "ns2-pinmux",
        .confops = &ns2_pinconf_ops,
        ...
};

위 코드의 ns2_pin_config_get() 함수에서 PIN_CONFIG_BIAS_DISABLE 항목이 설정되었는지를 알아보기 위해 pull 상태가 모두 다운인 경우에 한해서만 성공(0)을 반환함을 알 수 있다. 핀에 대해 상태를 알아오기 위해 다음의 명령에 따른 함수 호출 경로를 알아본다.

$ cat /sys/kernel/debug/pinctrl/pinconf-pins

  • &pinconf_pins_ops 파일 오퍼레이션의 (*open) 후크에 등록된 함수 호출 ->
  • pinconf_pins_open() ->
  • single_open()을 통해 pinconf_pins_show() 호출 ->
  • 등록된 핀 수만큼 루프
    • pinconf_dump_pin() 호출 ->
    • pinconf_pins_show() ->
    • pinconf_generic_dump_pins() ->
    • pinconf_generic_dump_one() ->
    • 설정 항목 만큼 루프(PIN_CONFIG_BIAS_BUS_HOLD(0) 부터 ~ PIN_CONFIG_SLEW_RATE 까지)
      • pin_config_get_for_pin() ->
      • pinconf_ops 오퍼레이션의 (*pin_config_get) 호크에 등록된 함수 호출 ->
      • ns2의 경우: ns2_pin_config_get()

 

ns2의 경우 실제 사용할 수 있는 pinconf 항목들은 다음과 같다.

  • bias-pull-disable
  • bias-pull-up
  • bias-pull-down
  • drive-strength
  • slew-rate
  • input-enable

 

다음 아래 코드에 있는 함수는 ns2_pin_config_get() 및 ns2_pin_config_set() 함수에서 호출하여 사용하는 함수로 실제 broadcom ns2의 pin controller(MFIO 레지스터)를 이용하여 pin에 대한 pull 상태를 확인하거나 pull 상태를 설정한다.

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

static void ns2_pin_get_pull(struct pinctrl_dev *pctrldev,
                             unsigned int pin, bool *pull_up,
                             bool *pull_down)
{
        struct ns2_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctrldev);
        struct ns2_pin *pin_data = pctrldev->desc->pins[pin].drv_data;
        unsigned long flags;
        u32 val;

        spin_lock_irqsave(&pinctrl->lock, flags);
        val = readl(pinctrl->pinconf_base + pin_data->pin_conf.offset);
        val = (val >> pin_data->pin_conf.pull_shift) & NS2_PIN_PULL_MASK;
        *pull_up = false;
        *pull_down = false;

        if (val == NS2_PIN_PULL_UP)
                *pull_up = true;

        if (val == NS2_PIN_PULL_DOWN)
                *pull_down = true;
        spin_unlock_irqrestore(&pinctrl->lock, flags);
}


static int ns2_pin_set_pull(struct pinctrl_dev *pctrldev, unsigned int pin,
                            bool pull_up, bool pull_down)
{
        struct ns2_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctrldev);
        struct ns2_pin *pin_data = pctrldev->desc->pins[pin].drv_data;
        unsigned long flags;
        u32 val;
        void __iomem *base_address;

        base_address = pinctrl->pinconf_base;
        spin_lock_irqsave(&pinctrl->lock, flags);
        val = readl(base_address + pin_data->pin_conf.offset);
        val &= ~(NS2_PIN_PULL_MASK << pin_data->pin_conf.pull_shift);

        if (pull_up == true)
                val |= NS2_PIN_PULL_UP << pin_data->pin_conf.pull_shift;
        if (pull_down == true)
                val |= NS2_PIN_PULL_DOWN << pin_data->pin_conf.pull_shift;
        writel(val, (base_address + pin_data->pin_conf.offset));
        spin_unlock_irqrestore(&pinctrl->lock, flags);

        dev_dbg(pctrldev->dev, "pin:%u set pullup:%d pulldown: %d\n",
                pin, pull_up, pull_down);
        return 0;
}

ns2에서 위의 pull 상태 설정 이외에도 다음과 같은 설정 함수가 사용되고 있다.

  • ns2_pin_set_strength()
  • ns2_pin_set_slew()
  • ns2_pin_set_enable()

 

Pinmux & Pinconf 매핑

pinmux 및 pinconf 등을 사용하기 위해 매핑 배열에 선언한 후 등록할 수 있다. 다음 두 개의 예에서는 “default” 이름을 가진 단일 state 만을 사용하였다.

 

Generic 사용 예 (deprecated)

매핑을 다음과 같이 매핑 배열에 선언한다.

  • name에 “default”를 사용하는 경우 1개의 default state 만으로 구성한다.
  • name에 여러 가지 이름을 사용하는 경우 등록한 이름으로 찾아서 수행시킬 수 있다.
#include <linux/pinctrl/machine.h>

static const struct pinctrl_map mapping[] __initconst = {
	{
		.dev_name = "foo-spi.0",
		.name = PINCTRL_STATE_DEFAULT,
		.type = PIN_MAP_TYPE_MUX_GROUP,
		.ctrl_dev_name = "pinctrl-foo",
		.data.mux.function = "spi0",
	},
	{
		.dev_name = "foo-i2c.0",
		.name = PINCTRL_STATE_DEFAULT,
		.type = PIN_MAP_TYPE_MUX_GROUP,
		.ctrl_dev_name = "pinctrl-foo",
		.data.mux.function = "i2c0",
	},
	{
		.dev_name = "foo-mmc.0",
		.name = PINCTRL_STATE_DEFAULT,
		.type = PIN_MAP_TYPE_MUX_GROUP,
		.ctrl_dev_name = "pinctrl-foo",
		.data.mux.function = "mmc0",
	},
};

 

또는 다음과 같이 PIN_MAP_MUX_GROUP() 매크로 함수를 사용하여 더 간단히 매핑을 만들 수도 있다.

#define PIN_MAP_MUX_GROUP(dev, state, pinctrl, grp, func)      \
        {                                                      \
                .dev_name = dev,                               \
                .name = state,                                 \
                .type = PIN_MAP_TYPE_MUX_GROUP,                \
                .ctrl_dev_name = pinctrl,                      \
                .data.mux = {                                  \
                .group = grp,                                  \
                .function = func,                              \
         },                                                    \
 }

static struct pinctrl_map mapping[] __initdata = {
	PIN_MAP_MUX_GROUP("foo-i2c.o", PINCTRL_STATE_DEFAULT, "pinctrl-foo", NULL, "i2c0"),
};

 

static unsigned long i2c_grp_configs[] = {
	FOO_PIN_DRIVEN,
	FOO_PIN_PULLUP,
};

static unsigned long i2c_pin_configs[] = {
	FOO_OPEN_COLLECTOR,
	FOO_SLEW_RATE_SLOW,
};

#define PIN_MAP_CONFIGS_GROUP(dev, state, pinctrl, grp, cfgs)           \
        {                                                               \
                .dev_name = dev,                                        \
                .name = state,                                          \
                .type = PIN_MAP_TYPE_CONFIGS_GROUP,                     \
                .ctrl_dev_name = pinctrl,                               \
                .data.configs = {                                       \
                        .group_or_pin = grp,                            \
                        .configs = cfgs,                                \
                        .num_configs = ARRAY_SIZE(cfgs),                \
                },                                                      \
        }

#define PIN_MAP_CONFIGS_PIN(dev, state, pinctrl, pin, cfgs)             \
        {                                                               \
                .dev_name = dev,                                        \
                .name = state,                                          \
                .type = PIN_MAP_TYPE_CONFIGS_PIN,                       \
                .ctrl_dev_name = pinctrl,                               \
                .data.configs = {                                       \
                        .group_or_pin = pin,                            \
                        .configs = cfgs,                                \
                        .num_configs = ARRAY_SIZE(cfgs),                \
                },                                                      \
        }

static struct pinctrl_map mapping[] __initdata = {
	PIN_MAP_MUX_GROUP("foo-i2c.0", PINCTRL_STATE_DEFAULT, "pinctrl-foo", "i2c0", "i2c0"),
	PIN_MAP_CONFIGS_GROUP("foo-i2c.0", PINCTRL_STATE_DEFAULT, "pinctrl-foo", "i2c0", i2c_grp_configs),
	PIN_MAP_CONFIGS_PIN("foo-i2c.0", PINCTRL_STATE_DEFAULT, "pinctrl-foo", "i2c0scl", i2c_pin_configs),
	PIN_MAP_CONFIGS_PIN("foo-i2c.0", PINCTRL_STATE_DEFAULT, "pinctrl-foo", "i2c0sda", i2c_pin_configs),
};

 

위에서 정의한 스테이트 별 pinmux/pinconf 매핑들을 등록할 때 다음 API를 사용한다.

.       ret = pinctrl_register_mappings(mapping, ARRAY_SIZE(mapping));

 

“default” 스테이트에 등록된 pinmux/pinconf 매핑을 찾아서 수행하려면 다음과 같이한다.

.       p = devm_pinctrl_get(dev);
	s = pinctrl_lookup_state(p, PINCTRL_STATE_DEFAULT);
	ret = pinctrl_select_state(p, s);

 

한 명령으로 더 간단히 수행하는 방법은 다음과 같다.

.	p = devm_pinctrl_get_select(dev, PINCTRL_STATE_DEFAULT);

 

디바이스 트리

최근에는 디바이스 드라이버 내부에서는 매핑을 미리 만들지 않고 디바이스 트리를 통해 매핑을 간단히 등록할 수 있게 하였다.

 

 

Pin Control APIs

  • pinctrl_get()
    • 요청한 디바이스에 해당하는 pinctrl 구조체를 알아오고자 할 때 사용한다.
    • 최근에는 디바이스 리소스 매니지먼트를 위해 devm_pinctrl_get() 함수를 사용한다.
  • pinctrl_put()
    • pinctrl_get()과 페어로 해제 시 사용한다.
    • 최근에는 디바이스 리소스 매니지먼트를 위해 devm_pinctrl_put() 함수를 사용한다.
  • pinctrl_lookup_state()
    • 클라이언트 디바이스를 위해 요청한 pinctrl과 state 이름으로 pinctrl_state를 찾아온다.
  • pinctrl_select_state()
    • state에 등록된 pinmux 또는 pinconf 매핑들을 HW에 적용한다.
  • gpio_request()
    • 클라이언트 디바이스 등에서 지정한 핀 번호의 gpio를 사용할 수 있다.
    • 최근에는 디바이스 리소스 매니지먼트를 위해 devm_gpio_request() 함수를 사용한다.

 

Debugfs 활용

CONFIG_DEBUG_FS 커널 옵션을 사용하는 경우 debugfs 가상 파일 시스템을 마운트하여 사용할 수 있다.

  • 보통 /sys/kernel/debug에 루트 계정으로 접근하여 사용할 수 있다.

 

rpi2 예)

“pinctrl-bcm28356″라는 이름의 pin controller 드라이버가 pinmux와 pinconf 둘 다 지원함을 알 수 있다.

# cd /sys/fs/debug/pinctrl
# ls -la
total 0
drwxr-xr-x  3 root root 0 Jan  1  1970 .
drwx------ 21 root root 0 Jan  1  1970 ..
drwxr-xr-x  2 root root 0 Jan  1  1970 3f200000.gpio
-r--r--r--  1 root root 0 Jan  1  1970 pinctrl-devices
-r--r--r--  1 root root 0 Jan  1  1970 pinctrl-handles
-r--r--r--  1 root root 0 Jan  1  1970 pinctrl-maps
# cat pinctrl-devices 
name [pinmux] [pinconf]
pinctrl-bcm2835 yes yes

 

다음 명령을 통해 매핑들을 리스트 형태로 조회한다.

  • 3f202000.sdhost 라는 이름의 클라이언트 디바이스
    • default state에 등록한 6개의 매핑들
      • pinmux: 48 ~ 54번 핀이 alt0 펑션을 사용
# cat pinctrl-handles 
Requested pin control handlers their pinmux maps:
device: 3f200000.gpio current state: none
device: 3f202000.sdhost current state: default
 state: default
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio48 (48) function: alt0 (4)
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio49 (49) function: alt0 (4)
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio50 (50) function: alt0 (4)
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio51 (51) function: alt0 (4)
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio52 (52) function: alt0 (4)
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio53 (53) function: alt0 (4)
device: 3f300000.mmc current state: default
 state: default
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio34 (34) function: alt3 (7)
 type: CONFIGS_PIN controller pinctrl-bcm2835 pin gpio34 (34)config 00000000
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio35 (35) function: alt3 (7)
 type: CONFIGS_PIN controller pinctrl-bcm2835 pin gpio35 (35)config 00000002
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio36 (36) function: alt3 (7)
 type: CONFIGS_PIN controller pinctrl-bcm2835 pin gpio36 (36)config 00000002
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio37 (37) function: alt3 (7)
 type: CONFIGS_PIN controller pinctrl-bcm2835 pin gpio37 (37)config 00000002
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio38 (38) function: alt3 (7)
 type: CONFIGS_PIN controller pinctrl-bcm2835 pin gpio38 (38)config 00000002
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio39 (39) function: alt3 (7)
 type: CONFIGS_PIN controller pinctrl-bcm2835 pin gpio39 (39)config 00000002
device: 3f201000.uart current state: default
 state: default
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio32 (32) function: alt3 (7)
 type: CONFIGS_PIN controller pinctrl-bcm2835 pin gpio32 (32)config 00000000
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio33 (33) function: alt3 (7)
 type: CONFIGS_PIN controller pinctrl-bcm2835 pin gpio33 (33)config 00000002
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio43 (43) function: alt0 (4)
 type: CONFIGS_PIN controller pinctrl-bcm2835 pin gpio43 (43)config 00000000
device: 3f804000.i2c current state: default
 state: default
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio2 (2) function: alt0 (4)
 type: MUX_GROUP controller pinctrl-bcm2835 group: gpio3 (3) function: alt0 (4)

 

다음 명령을 통해 매핑들을 더욱 자세하게 조회한다.

# cat pinctrl-maps 
Pinctrl maps:
Pinctrl maps:
device 3f202000.sdhost
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio48
function alt0

device 3f202000.sdhost
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio49
function alt0

device 3f202000.sdhost
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio50
function alt0

device 3f202000.sdhost
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio51
function alt0

device 3f202000.sdhost
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio52
function alt0

device 3f202000.sdhost
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio53
function alt0

device 3f300000.mmc
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio34
function alt3

device 3f300000.mmc
state default
type CONFIGS_PIN (3)
controlling device 3f200000.gpio
pin gpio34
config 00000000

device 3f300000.mmc
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio35
function alt3

device 3f300000.mmc
state default
type CONFIGS_PIN (3)
controlling device 3f200000.gpio
pin gpio35
config 00000002

device 3f300000.mmc
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio36
function alt3

device 3f300000.mmc
state default
type CONFIGS_PIN (3)
controlling device 3f200000.gpio
pin gpio36
config 00000002

device 3f300000.mmc
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio37
function alt3

device 3f300000.mmc
state default
type CONFIGS_PIN (3)
controlling device 3f200000.gpio
pin gpio37
config 00000002

device 3f300000.mmc
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio38
function alt3

device 3f300000.mmc
state default
type CONFIGS_PIN (3)
controlling device 3f200000.gpio
pin gpio38
config 00000002

device 3f300000.mmc
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio39
function alt3

device 3f300000.mmc
state default
type CONFIGS_PIN (3)
controlling device 3f200000.gpio
pin gpio39
config 00000002

device 3f201000.uart
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio32
function alt3

device 3f201000.uart
state default
type CONFIGS_PIN (3)
controlling device 3f200000.gpio
pin gpio32
config 00000000

device 3f201000.uart
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio33
function alt3

device 3f201000.uart
state default
type CONFIGS_PIN (3)
controlling device 3f200000.gpio
pin gpio33
config 00000002

device 3f201000.uart
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio43
function alt0

device 3f201000.uart
state default
type CONFIGS_PIN (3)
controlling device 3f200000.gpio
pin gpio43
config 00000000

device 3f804000.i2c
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio2
function alt0

device 3f804000.i2c
state default
type MUX_GROUP (2)
controlling device 3f200000.gpio
group gpio3
function alt0

 

# cd 3f200000.gpio/
# ls -la
total 0
drwxr-xr-x 2 root root 0 Jan  1  1970 .
drwxr-xr-x 3 root root 0 Jan  1  1970 ..
-r--r--r-- 1 root root 0 Jan  1  1970 gpio-ranges
-rw-rw-r-- 1 root root 0 Jan  1  1970 pinconf-config
-r--r--r-- 1 root root 0 Jan  1  1970 pinconf-groups
-r--r--r-- 1 root root 0 Jan  1  1970 pinconf-pins
-r--r--r-- 1 root root 0 Jan  1  1970 pingroups
-r--r--r-- 1 root root 0 Jan  1  1970 pinmux-functions
-r--r--r-- 1 root root 0 Jan  1  1970 pinmux-pins
-r--r--r-- 1 root root 0 Jan  1  1970 pins

rpi2의 경우 pin controller가 다루는 0 ~ 53번이 모두 gpio 핀과 1:1로 대응하는 것을 알 수 있다. 커널에서 gpio를 사용하려면 반드시 gpio-ranges에 등록되어 있어야 한다.

# cat gpio-ranges 
GPIO ranges handled:
0: pinctrl-bcm2835 GPIOS [0 - 53] PINS [0 - 53]

 

다음과 같이 0~53번 핀에 해당하는 그룹명이 괄호안에 표시되고, 추가 설정들이 콜론 뒤에 보여진다.

  • rpi2의 경우 모든 핀에 추가 설정이 없음을 알 수 있다.
# cat pinconf-groups 
Pin config settings per pin group
Format: group (name): configs
0 (gpio0):
1 (gpio1):
...
52 (gpio52):
53 (gpio53):

 

각 pin 별로 그룹 멤버십, pinmux 오너, gpio 오너등을 알 수 있다.

  • 예: pin 2번과 3번은 i2c를 사용하기 위해 alt0 기능을 사용한다.
# cat pinmux-pins 
Pinmux settings per pin
Format: pin (name): mux_owner gpio_owner hog?
pin 0 (gpio0): (MUX UNCLAIMED) (GPIO UNCLAIMED)
pin 1 (gpio1): (MUX UNCLAIMED) (GPIO UNCLAIMED)
pin 2 (gpio2): 3f804000.i2c (GPIO UNCLAIMED) function alt0 group gpio2
pin 3 (gpio3): 3f804000.i2c (GPIO UNCLAIMED) function alt0 group gpio3
pin 4 (gpio4): (MUX UNCLAIMED) (GPIO UNCLAIMED)
...
pin 31 (gpio31): (MUX UNCLAIMED) (GPIO UNCLAIMED)
pin 32 (gpio32): 3f201000.uart (GPIO UNCLAIMED) function alt3 group gpio32
pin 33 (gpio33): 3f201000.uart (GPIO UNCLAIMED) function alt3 group gpio33
pin 34 (gpio34): 3f300000.mmc (GPIO UNCLAIMED) function alt3 group gpio34
pin 35 (gpio35): 3f300000.mmc (GPIO UNCLAIMED) function alt3 group gpio35
pin 36 (gpio36): 3f300000.mmc (GPIO UNCLAIMED) function alt3 group gpio36
pin 37 (gpio37): 3f300000.mmc (GPIO UNCLAIMED) function alt3 group gpio37
pin 38 (gpio38): 3f300000.mmc (GPIO UNCLAIMED) function alt3 group gpio38
pin 39 (gpio39): 3f300000.mmc (GPIO UNCLAIMED) function alt3 group gpio39
pin 40 (gpio40): (MUX UNCLAIMED) (GPIO UNCLAIMED)
pin 41 (gpio41): (MUX UNCLAIMED) (GPIO UNCLAIMED)
pin 42 (gpio42): (MUX UNCLAIMED) (GPIO UNCLAIMED)
pin 43 (gpio43): 3f201000.uart (GPIO UNCLAIMED) function alt0 group gpio43
pin 44 (gpio44): (MUX UNCLAIMED) (GPIO UNCLAIMED)
pin 45 (gpio45): (MUX UNCLAIMED) (GPIO UNCLAIMED)
pin 46 (gpio46): (MUX UNCLAIMED) (GPIO UNCLAIMED)
pin 47 (gpio47): (MUX UNCLAIMED) (GPIO UNCLAIMED)
pin 48 (gpio48): 3f202000.sdhost (GPIO UNCLAIMED) function alt0 group gpio48
pin 49 (gpio49): 3f202000.sdhost (GPIO UNCLAIMED) function alt0 group gpio49
pin 50 (gpio50): 3f202000.sdhost (GPIO UNCLAIMED) function alt0 group gpio50
pin 51 (gpio51): 3f202000.sdhost (GPIO UNCLAIMED) function alt0 group gpio51
pin 52 (gpio52): 3f202000.sdhost (GPIO UNCLAIMED) function alt0 group gpio52
pin 53 (gpio53): 3f202000.sdhost (GPIO UNCLAIMED) function alt0 group gpio53

 

최근에 변경된 핀 설정(pinconf)이 있는 경우 보여준다.

# cat pinconf-config 
No config found for dev/state/pin, expected:
Searched dev:
Searched state:
Searched pin:
Use: modify config_pin <devname> <state> <pinname> <value>

 

0~53번 핀에 대한 핀 명과 설정들을 리스트로 보여준다.

  • 주의: 핀명과 핀 그룹명이 동일하다.
# cat pinconf-pins 
Pin config settings per pin
Format: pin (name): configs
pin 0 (gpio0):
pin 1 (gpio1):
...
pin 52 (gpio52):
pin 53 (gpio53):

 

현재 펑션별로 설정된 그룹들을 보여준다.

# cat pinmux-functions 
function: gpio_in, groups = [ gpio0 gpio1 gpio2 gpio3 gpio4 gpio5 gpio6 gpio7 gpio8 gpio9 gpio10 gpio11 gpio12 gpio13 gpio14 gpio15 gpio16 gpio17 gpio18 gpio19 gpio20 gpio21 gpio22 gpio23 gpio24 gpio25 gpio26 gpio27 gpio28 gpio29 gpio30 gpio31 gpio32 gpio33 gpio34 gpio35 gpio36 gpio37 gpio38 gpio39 gpio40 gpio41 gpio42 gpio43 gpio44 gpio45 gpio46 gpio47 gpio48 gpio49 gpio50 gpio51 gpio52 gpio53 ]
function: gpio_out, groups = [ gpio0 gpio1 gpio2 gpio3 gpio4 gpio5 gpio6 gpio7 gpio8 gpio9 gpio10 gpio11 gpio12 gpio13 gpio14 gpio15 gpio16 gpio17 gpio18 gpio19 gpio20 gpio21 gpio22 gpio23 gpio24 gpio25 gpio26 gpio27 gpio28 gpio29 gpio30 gpio31 gpio32 gpio33 gpio34 gpio35 gpio36 gpio37 gpio38 gpio39 gpio40 gpio41 gpio42 gpio43 gpio44 gpio45 gpio46 gpio47 gpio48 gpio49 gpio50 gpio51 gpio52 gpio53 ]
function: alt5, groups = [ gpio0 gpio1 gpio2 gpio3 gpio4 gpio5 gpio6 gpio7 gpio8 gpio9 gpio10 gpio11 gpio12 gpio13 gpio14 gpio15 gpio16 gpio17 gpio18 gpio19 gpio20 gpio21 gpio22 gpio23 gpio24 gpio25 gpio26 gpio27 gpio28 gpio29 gpio30 gpio31 gpio32 gpio33 gpio34 gpio35 gpio36 gpio37 gpio38 gpio39 gpio40 gpio41 gpio42 gpio43 gpio44 gpio45 gpio46 gpio47 gpio48 gpio49 gpio50 gpio51 gpio52 gpio53 ]
function: alt4, groups = [ gpio0 gpio1 gpio2 gpio3 gpio4 gpio5 gpio6 gpio7 gpio8 gpio9 gpio10 gpio11 gpio12 gpio13 gpio14 gpio15 gpio16 gpio17 gpio18 gpio19 gpio20 gpio21 gpio22 gpio23 gpio24 gpio25 gpio26 gpio27 gpio28 gpio29 gpio30 gpio31 gpio32 gpio33 gpio34 gpio35 gpio36 gpio37 gpio38 gpio39 gpio40 gpio41 gpio42 gpio43 gpio44 gpio45 gpio46 gpio47 gpio48 gpio49 gpio50 gpio51 gpio52 gpio53 ]
function: alt0, groups = [ gpio0 gpio1 gpio2 gpio3 gpio4 gpio5 gpio6 gpio7 gpio8 gpio9 gpio10 gpio11 gpio12 gpio13 gpio14 gpio15 gpio16 gpio17 gpio18 gpio19 gpio20 gpio21 gpio22 gpio23 gpio24 gpio25 gpio26 gpio27 gpio28 gpio29 gpio30 gpio31 gpio32 gpio33 gpio34 gpio35 gpio36 gpio37 gpio38 gpio39 gpio40 gpio41 gpio42 gpio43 gpio44 gpio45 gpio46 gpio47 gpio48 gpio49 gpio50 gpio51 gpio52 gpio53 ]
function: alt1, groups = [ gpio0 gpio1 gpio2 gpio3 gpio4 gpio5 gpio6 gpio7 gpio8 gpio9 gpio10 gpio11 gpio12 gpio13 gpio14 gpio15 gpio16 gpio17 gpio18 gpio19 gpio20 gpio21 gpio22 gpio23 gpio24 gpio25 gpio26 gpio27 gpio28 gpio29 gpio30 gpio31 gpio32 gpio33 gpio34 gpio35 gpio36 gpio37 gpio38 gpio39 gpio40 gpio41 gpio42 gpio43 gpio44 gpio45 gpio46 gpio47 gpio48 gpio49 gpio50 gpio51 gpio52 gpio53 ]
function: alt2, groups = [ gpio0 gpio1 gpio2 gpio3 gpio4 gpio5 gpio6 gpio7 gpio8 gpio9 gpio10 gpio11 gpio12 gpio13 gpio14 gpio15 gpio16 gpio17 gpio18 gpio19 gpio20 gpio21 gpio22 gpio23 gpio24 gpio25 gpio26 gpio27 gpio28 gpio29 gpio30 gpio31 gpio32 gpio33 gpio34 gpio35 gpio36 gpio37 gpio38 gpio39 gpio40 gpio41 gpio42 gpio43 gpio44 gpio45 gpio46 gpio47 gpio48 gpio49 gpio50 gpio51 gpio52 gpio53 ]
function: alt3, groups = [ gpio0 gpio1 gpio2 gpio3 gpio4 gpio5 gpio6 gpio7 gpio8 gpio9 gpio10 gpio11 gpio12 gpio13 gpio14 gpio15 gpio16 gpio17 gpio18 gpio19 gpio20 gpio21 gpio22 gpio23 gpio24 gpio25 gpio26 gpio27 gpio28 gpio29 gpio30 gpio31 gpio32 gpio33 gpio34 gpio35 gpio36 gpio37 gpio38 gpio39 gpio40 gpio41 gpio42 gpio43 gpio44 gpio45 gpio46 gpio47 gpio48 gpio49 gpio50 gpio51 gpio52 gpio53 ]

 

핀에 대한 상태와 연결된 인터럽트 번호를 보여준다.

# cat pins 
registered pins: 54
pin 0 (gpio0) function gpio_in in hi; irq 166 (none)
pin 1 (gpio1) function gpio_in in hi; irq 167 (none)
pin 2 (gpio2) function alt0 in hi; irq 168 (none)
pin 3 (gpio3) function alt0 in hi; irq 169 (none)
pin 4 (gpio4) function gpio_in in hi; irq 170 (none)
pin 5 (gpio5) function gpio_in in hi; irq 171 (none)
...
pin 30 (gpio30) function gpio_in in lo; irq 196 (none)
pin 31 (gpio31) function gpio_in in lo; irq 197 (none)
pin 32 (gpio32) function alt3 in hi; irq 198 (none)
...
pin 41 (gpio41) function alt0 in hi; irq 207 (none)
pin 42 (gpio42) function alt0 in lo; irq 208 (none)
pin 43 (gpio43) function alt0 in hi; irq 209 (none)
pin 44 (gpio44) function gpio_in in hi; irq 210 (none)
pin 45 (gpio45) function gpio_in in hi; irq 211 (none)
pin 46 (gpio46) function gpio_in in hi; irq 212 (none)
pin 47 (gpio47) function gpio_in in hi; irq 213 (none)
pin 48 (gpio48) function alt0 in lo; irq 214 (none)
pin 49 (gpio49) function alt0 in hi; irq 215 (none)
...

 

GPIO 유저 스페이스에서 활용

# cd /sys/class/gpio/
# ls
root@raspberrypi:/sys/class/gpio# ls
export	gpiochip0  unexport
# echo 23 > export
# cd  gpio23
# ls
active_low  device  direction  edge  subsystem	uevent	value
# # cat active_low 
0
# cat direction 
in
# cat edge 
none
# cat value 
0
# cd ..
# echo 23 > unexport

 

참고

 

답글 남기기

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