DRM 코어 및 디스플레이 (KMS)

Linux DRM(Direct Rendering Manager) 코어 아키텍처와 KMS(Kernel Mode Setting) 디스플레이 파이프라인을 심층 분석합니다. DRM 디바이스 노드와 권한 모델, KMS 객체(CRTC/plane/encoder/connector), atomic modesetting, DRM properties, VRR(Variable Refresh Rate), format modifier, DRM bridge/panel, 디스플레이 연결 프로토콜, HDCP content protection, DRM lease, fbdev 에뮬레이션, 주요 오픈소스 DRM 드라이버 구조를 다룹니다.

DRM (Direct Rendering Manager) 개요

DRM은 Linux 커널의 GPU 접근을 관리하는 서브시스템입니다. 원래 3D 그래픽 가속을 위해 도입되었으나, 현재는 디스플레이 출력(KMS), GPU 메모리 관리(GEM/TTM), GPU 작업 스케줄링까지 포괄하는 핵심 프레임워크로 발전했습니다.

디바이스 노드와 권한 모델

현대 DRM UAPI는 GPU 하나를 단일 문자 디바이스로만 노출하지 않습니다. 같은 하드웨어라도 화면 제어, 비특권 렌더링, 비그래픽 연산을 서로 다른 노드로 나누어 권한 경계와 사용자 공간(User Space) 스택을 분리합니다. 이 구분을 이해하지 못하면 drm_file의 인증 상태, client capability, 버퍼 공유 규칙, compositor와 compute runtime의 역할이 한꺼번에 흐려집니다.

/* 유저 공간은 node 종류와 client capability를 먼저 협상합니다 */
int fd = open("/dev/dri/card0", O_RDWR | O_CLOEXEC);
drmSetClientCap(fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
drmSetClientCap(fd, DRM_CLIENT_CAP_ATOMIC, 1);
drmSetClientCap(fd, DRM_CLIENT_CAP_WRITEBACK_CONNECTORS, 1);

/* para-virtual GPU에서는 커서 plane hotspot capability가 추가로 필요할 수 있습니다 */
drmSetClientCap(fd, DRM_CLIENT_CAP_CURSOR_PLANE_HOTSPOT, 1);

DRM 아키텍처

유저 공간 그래픽 스택

DRM/KMS 위에서 동작하는 유저 공간 소프트웨어 스택의 구조입니다. 각 계층이 DRM을 어떻게 활용하는지 이해하면 전체 그래픽 파이프라인을 파악할 수 있습니다.

DRM 핵심 구조체(Struct)

drm_device & drm_driver

drm_device는 하나의 GPU 디바이스를 나타내고, drm_driver는 해당 GPU 유형의 오퍼레이션을 정의합니다.

#include <drm/drm_drv.h>
#include <drm/drm_gem.h>
#include <drm/drm_ioctl.h>

/* DRM 드라이버 정의 — 드라이버 전체에 하나 */
static const struct drm_driver my_gpu_driver = {
    .driver_features    = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC |
                          DRIVER_RENDER,
    /* GEM 오퍼레이션 */
    .gem_prime_import   = drm_gem_prime_import,
    .gem_prime_import_sg_table = drm_gem_shmem_prime_import_sg_table,

    /* DRM ioctl 테이블 (드라이버 고유 ioctl) */
    .ioctls             = my_gpu_ioctls,
    .num_ioctls         = ARRAY_SIZE(my_gpu_ioctls),

    /* /sys, /dev 노드 이름 */
    .name               = "my-gpu",
    .desc               = "My GPU DRM driver",
    .date               = "20260101",
    .major              = 1,
    .minor              = 0,

    .fops               = &my_gpu_fops,
};

drm_file (파일 프라이빗)

유저 프로세스(Process)가 DRM/accel 노드를 open하면 drm_file 구조체가 생성됩니다. 이 구조체는 “프로세스별 GPU 컨텍스트”라기보다 파일 디스크립터별 세션 상태에 가깝고, 인증 여부, master 여부, client capability, 핸들 테이블, 이벤트 큐를 함께 들고 있습니다.

/* drm_file 핵심 필드 발췌 (include/drm/drm_file.h) */
struct drm_file {
    bool               authenticated; /* 레거시 primary 노드 렌더 권한 */
    bool               universal_planes;
    bool               atomic;
    bool               writeback_connectors;
    bool               is_master;
    bool               supports_virtualized_cursor_plane;
    struct drm_minor   *minor;        /* primary/render/accel 중 어떤 노드를 열었는지 */
    struct idr         object_idr;    /* GEM 핸들 → drm_gem_object 매핑 */
    struct idr         syncobj_idr;   /* drm_syncobj 핸들 테이블 */
    struct list_head   pending_event_list;
    struct list_head   event_list;    /* vblank, page flip, out-fence 이벤트 */
    void              *driver_priv;   /* 드라이버별 프라이빗 데이터 */
};

KMS (Kernel Mode Setting)

KMS는 커널에서 디스플레이 모드를 설정하는 프레임워크입니다. 기존의 유저 공간 모드 설정(UMS)과 달리, 커널이 직접 해상도/주사율/디스플레이 파이프라인을 제어하여 콘솔↔그래픽 전환 시 깜박임이 없고 다중 모니터를 안정적으로 관리합니다.

KMS 핵심 오브젝트

Vblank 처리와 페이지(Page) 플립

Vblank(수직 귀선 기간)은 디스플레이가 한 프레임을 마치고 다음 프레임을 시작하기 직전의 시간 구간입니다. 이 시점에 프레임버퍼를 교체(page flip)해야 화면 찢어짐(tearing)이 발생하지 않습니다. DRM 코어는 drm_vblank 인프라로 정확한 vblank 타이밍과 시퀀스 번호를 관리합니다.

/* Vblank 관련 드라이버 콜백 */
static const struct drm_crtc_funcs my_crtc_funcs = {
    /* vblank 카운터/타임스탬프 제공 */
    .get_vblank_counter  = drm_crtc_vblank_count,
    .enable_vblank       = my_enable_vblank,   /* vblank IRQ 활성화 */
    .disable_vblank      = my_disable_vblank,  /* vblank IRQ 비활성화 */
    .get_vblank_timestamp = drm_crtc_vblank_helper_get_vblank_timestamp,
};

/* 드라이버 vblank IRQ 핸들러 */
static irqreturn_t my_irq_handler(int irq, void *data)
{
    struct drm_device *dev = data;
    u32 status = readl(regs + IRQ_STATUS);

    if (status & VBLANK_IRQ) {
        drm_crtc_handle_vblank(&my_crtc);  /* vblank 카운터 증가 + 이벤트 전달 */
    }
    return IRQ_HANDLED;
}

/* 페이지 플립 완료 알림 (vblank IRQ에서 호출) */
if (page_flip_pending) {
    drm_crtc_send_vblank_event(&my_crtc, event);
    drm_crtc_vblank_put(&my_crtc);
    page_flip_pending = false;
}

Atomic Modesetting

Atomic modesetting은 KMS의 현대적 커밋 모델입니다. 여러 디스플레이 속성 변경을 하나의 원자적(Atomic) 트랜잭션(Transaction)으로 묶어 중간 상태 없이 적용하거나 전체를 롤백(Rollback)합니다.

Atomic 상태 객체 그래프

실제 atomic UAPI의 핵심은 “property를 바로 레지스터(Register)에 쓰는 것”이 아니라, drm_atomic_state 아래에 CRTC/plane/connector/private object의 새 상태를 모아 둔 뒤 한 번에 검증하고 커밋하는 것입니다. driver의 atomic_check는 이 그래프 전체를 보고 대역폭(Bandwidth), scaler 수, watermark, 링크 훈련 가능 여부, color LUT 크기, writeback 출력 버퍼 충돌까지 판단합니다.

/* Atomic 커밋 흐름 (커널 내부) */

/* 1. 유저가 DRM_IOCTL_MODE_ATOMIC 호출 */
/*    → drm_mode_atomic_ioctl() 진입 */

/* 2. 상태 복제 */
struct drm_atomic_state *state = drm_atomic_state_alloc(dev);
/* 각 오브젝트의 현재 상태를 복제하여 new_state 생성 */

/* 3. 속성 적용 (유저가 요청한 변경사항) */
drm_atomic_set_crtc_for_connector(new_conn_state, crtc);
new_crtc_state->mode_blob = mode;
new_plane_state->fb = framebuffer;
new_plane_state->crtc = crtc;

/* 4. 검증 (atomic_check) — 하드웨어 제약 확인 */
ret = drm_atomic_check_only(state);
/* 각 CRTC/Plane/Connector의 atomic_check 콜백 호출 */
/* 실패 시 -EINVAL 반환, 유저에게 거부 통보 */

/* 5. TEST_ONLY 플래그면 여기서 종료 (검증만 수행) */
if (flags & DRM_MODE_ATOMIC_TEST_ONLY)
    return ret;

/* 6. 커밋 (atomic_commit) — 실제 하드웨어 적용 */
ret = drm_atomic_commit(state);
/* NONBLOCK 플래그: 비동기 커밋 (vsync 대기 안 함) */
/* PAGE_FLIP_EVENT: 완료 시 유저에게 이벤트 전달 */

DRM Properties 시스템

KMS 오브젝트(CRTC, Plane, Connector)의 모든 설정 가능한 속성은 DRM Property로 표현됩니다. Atomic modesetting에서는 property ID와 값을 쌍으로 전달하여 디스플레이 상태를 변경합니다.

Property 타입

표준 KMS Property

/* === CRTC Properties === */
"ACTIVE"           /* bool: CRTC 활성화 (atomic에서 DPMS 대체) */
"MODE_ID"          /* blob: 디스플레이 모드 (해상도/주사율) */
"OUT_FENCE_PTR"    /* ptr: 커밋 완료 fence fd 반환 위치 */
"VRR_ENABLED"      /* bool: 가변 주사율 활성화 */
"DEGAMMA_LUT"      /* blob: 디감마 LUT (Color Management) */
"CTM"              /* blob: 색 변환 매트릭스 (3x3, S31.32 고정소수) */
"GAMMA_LUT"        /* blob: 감마 LUT */

/* === Plane Properties === */
"FB_ID"            /* object: 표시할 프레임버퍼 */
"CRTC_ID"         /* object: 연결할 CRTC */
"SRC_X/Y/W/H"     /* range: 소스 영역 (16.16 고정소수점) */
"CRTC_X/Y/W/H"    /* range: 화면 위 위치/크기 (스케일링) */
"rotation"         /* bitmask: ROTATE_0/90/180/270 | REFLECT_X/Y */
"alpha"            /* range: 투명도 (0=투명, 0xFFFF=불투명) */
"pixel blend mode" /* enum: None/Pre-multiplied/Coverage */
"zpos"             /* range: 레이어 순서 (높을수록 위) */
"IN_FENCE_FD"      /* range: explicit sync 입력 fence fd */
"COLOR_ENCODING"   /* enum: YCbCr BT.601/709/2020 */
"COLOR_RANGE"      /* enum: YCbCr Limited/Full Range */

/* === Connector Properties === */
"CRTC_ID"          /* object: 연결할 CRTC */
"DPMS"             /* enum: On/Standby/Suspend/Off (레거시) */
"link-status"      /* enum: Good/Bad — 링크 학습 실패 시 Bad */
"EDID"             /* blob: 모니터 EDID 바이너리 (읽기 전용) */
"content type"     /* enum: No Data/Graphics/Photo/Cinema/Game */
"max bpc"          /* range: 최대 색 깊이 (bits per component) */
"HDR_OUTPUT_METADATA" /* blob: HDR 정적/동적 메타데이터 */
"vrr_capable"      /* range: 모니터 VRR 지원 여부 (읽기 전용) */

/* 드라이버에서 커스텀 property 등록 */
struct drm_property *prop;

/* Enum property 생성 */
static const struct drm_prop_enum_list my_scaling_modes[] = {
    { 0, "None" },
    { 1, "Full" },
    { 2, "Center" },
    { 3, "Full aspect" },
};
prop = drm_property_create_enum(dev, 0, "scaling mode",
        my_scaling_modes, ARRAY_SIZE(my_scaling_modes));

/* CRTC에 property 연결 */
drm_object_attach_property(&crtc->base, prop, 0);

/* atomic_check에서 property 값 읽기 */
static int my_crtc_atomic_check(struct drm_crtc *crtc,
                                struct drm_atomic_state *state)
{
    struct drm_crtc_state *crtc_state =
        drm_atomic_get_new_crtc_state(state, crtc);
    /* crtc_state에서 property 값에 접근 */
    ...
}

Color Management 파이프라인

KMS는 CRTC 레벨에서 3단계 색상 처리 파이프라인을 제공합니다. 이 파이프라인으로 HDR 톤매핑, 색 공간 변환, 감마 보정 등을 하드웨어 가속으로 수행합니다.

/* Color Management 관련 구조체 */

/* 감마/디감마 LUT 엔트리 (유저 공간에서 설정) */
struct drm_color_lut {
    __u16 red;      /* 0~0xFFFF */
    __u16 green;
    __u16 blue;
    __u16 reserved;
};

/* 색 변환 매트릭스 (CTM) — S31.32 고정소수점 */
struct drm_color_ctm {
    __u64 matrix[9];   /* 3x3, 부호 비트 + 31.32 고정소수 */
};

/* 유저 공간에서 감마 LUT 설정 예시 (libdrm) */
struct drm_color_lut lut[256];
for (int i = 0; i < 256; i++) {
    /* sRGB 감마 커브: 선형 → sRGB 비선형 */
    double v = (double)i / 255.0;
    double srgb = (v <= 0.0031308) ?
        v * 12.92 : 1.055 * pow(v, 1.0/2.4) - 0.055;
    __u16 val = (__u16)(srgb * 0xFFFF);
    lut[i].red = lut[i].green = lut[i].blue = val;
}
/* blob property로 설정 */
drmModeCreatePropertyBlob(fd, lut, sizeof(lut), &blob_id);
/* atomic 커밋에 GAMMA_LUT=blob_id 추가 */

VRR (Variable Refresh Rate) / Adaptive Sync

VRR은 GPU 렌더링 속도에 맞춰 디스플레이 주사율을 동적으로 조절하는 기술입니다. 화면 찢어짐(tearing)과 스터터링(stuttering) 없이 부드러운 프레임 전달을 가능하게 합니다.

/* VRR 활성화 흐름 (커널 내부) */

/* 1. Connector가 VRR 지원하는지 확인 */
/*    모니터 EDID의 Adaptive-Sync range 파싱 */
connector->vrr_capable = true;  /* 드라이버가 EDID 기반으로 설정 */

/* 2. 유저 공간에서 CRTC의 VRR_ENABLED property 설정 */
/*    → atomic commit에 포함 */
new_crtc_state->vrr_enabled = true;

/* 3. 드라이버 atomic_check에서 VRR 설정 검증 */
static int my_crtc_atomic_check(struct drm_crtc *crtc,
                                struct drm_atomic_state *state)
{
    struct drm_crtc_state *crtc_state =
        drm_atomic_get_new_crtc_state(state, crtc);

    if (crtc_state->vrr_enabled) {
        /* VRR 범위 확인 (min_vfreq ~ max_vfreq) */
        struct drm_connector *conn = get_connector(crtc_state);
        if (!conn->display_info.monitor_range.max_vfreq)
            return -EINVAL;

        /* 하드웨어 VRR 타이밍 설정 */
        my_state->vmin = conn->display_info.monitor_range.min_vfreq;
        my_state->vmax = conn->display_info.monitor_range.max_vfreq;
    }
    return 0;
}

/* 4. 페이지 플립 시 VRR 타이밍 적용 */
/*    GPU가 프레임을 완료하면 즉시 vsync 발생 */
/*    → 가변 vblank 주기 */

Format Modifier (타일링/압축)

GPU는 메모리 접근 효율을 위해 픽셀 데이터를 단순 행(linear) 방식이 아닌 타일(tile) 형태로 배치합니다. Format Modifier는 프레임버퍼의 메모리 레이아웃을 기술하는 64비트 토큰입니다.

/* Format Modifier 구조 (include/uapi/drm/drm_fourcc.h) */
/*
 * [63:56] = vendor (DRM_FORMAT_MOD_VENDOR_*)
 * [55:0]  = vendor별 modifier 값
 *
 * 0 = DRM_FORMAT_MOD_LINEAR (행 순차 배치, 모든 디바이스 공통)
 */

#define DRM_FORMAT_MOD_LINEAR  0

/* Intel 타일링 modifier 예시 */
#define I915_FORMAT_MOD_X_TILED    /* X-tiling (레거시) */
#define I915_FORMAT_MOD_Y_TILED    /* Y-tiling (Gen9+) */
#define I915_FORMAT_MOD_4_TILED    /* Tile-4 (Gen12.5+, DG2/MTL) */
#define I915_FORMAT_MOD_Y_TILED_CCS /* Y-tiling + CCS 압축 */

/* AMD modifier 예시 */
#define AMD_FMT_MOD                /* 타일 버전, pipe_xor_bits, DCC 등 인코딩 */

/* ARM AFBC (Arm Frame Buffer Compression) */
#define DRM_FORMAT_MOD_ARM_AFBC    /* Mali GPU 프레임버퍼 무손실 압축 */

/* Broadcom */
#define DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED /* VideoCore T-tiling */

/* NVIDIA */
#define DRM_FORMAT_MOD_NVIDIA_BLOCK_LINEAR_2D /* GOB 기반 타일링 */

/* 프레임버퍼 생성 시 modifier 지정 (ADDFB2) */
struct drm_mode_fb_cmd2 cmd = {
    .width   = 1920,
    .height  = 1080,
    .pixel_format = DRM_FORMAT_XRGB8888,
    .handles[0] = gem_handle,
    .pitches[0] = pitch,
    .modifier[0] = I915_FORMAT_MOD_Y_TILED, /* modifier 지정 */
    .flags   = DRM_MODE_FB_MODIFIERS,       /* modifier 사용 플래그 */
};
drmIoctl(fd, DRM_IOCTL_MODE_ADDFB2, &cmd);

/* Plane이 지원하는 modifier 목록 조회 */
/* DRM_IOCTL_MODE_GETPLANE2 또는 IN_FORMATS blob property */
/* → (format, modifier) 쌍의 목록 반환 */

/* 드라이버: Plane에 지원 modifier 등록 */
static const uint64_t my_modifiers[] = {
    DRM_FORMAT_MOD_LINEAR,
    I915_FORMAT_MOD_Y_TILED,
    I915_FORMAT_MOD_Y_TILED_CCS,
    DRM_FORMAT_MOD_INVALID  /* 종료 마커 */
};
drm_universal_plane_init(dev, plane, ...,
    formats, num_formats, my_modifiers, ...);

DRM 드라이버 기본 구조

최소한의 KMS DRM 드라이버 (디스플레이만 지원, GPU 가속 없음)의 골격입니다.

#include <linux/module.h>
#include <linux/platform_device.h>
#include <drm/drm_drv.h>
#include <drm/drm_gem_shmem_helper.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_simple_kms_helper.h>
#include <drm/drm_fbdev_shmem.h>

struct my_drm {
    struct drm_device              drm;
    struct drm_simple_display_pipe pipe;
    struct drm_connector           connector;
    void __iomem                  *regs;
};

/* --- Connector --- */
static int my_connector_get_modes(struct drm_connector *conn)
{
    /* 고정 해상도 모드 추가 (실제로는 EDID 파싱) */
    return drm_add_modes_noedid(conn, 1920, 1080);
}

static const struct drm_connector_helper_funcs my_conn_helpers = {
    .get_modes = my_connector_get_modes,
};

/* --- Simple Display Pipe --- */
static void my_pipe_enable(struct drm_simple_display_pipe *pipe,
                           struct drm_crtc_state *crtc_state,
                           struct drm_plane_state *plane_state)
{
    struct my_drm *my = container_of(pipe, struct my_drm, pipe);
    struct drm_framebuffer *fb = plane_state->fb;

    /* 하드웨어 레지스터에 프레임버퍼 주소/포맷 설정 */
    writel(drm_fb_dma_get_gem_addr(fb, plane_state, 0),
           my->regs + FB_ADDR_REG);
    writel(fb->pitches[0], my->regs + FB_PITCH_REG);
    /* 디스플레이 엔진 활성화 */
    writel(1, my->regs + DISPLAY_ENABLE_REG);
}

static void my_pipe_update(struct drm_simple_display_pipe *pipe,
                           struct drm_plane_state *old_state)
{
    struct drm_plane_state *state = pipe->plane.state;
    if (state->fb)
        my_pipe_enable(pipe, NULL, state);
}

static const struct drm_simple_display_pipe_funcs my_pipe_funcs = {
    .enable  = my_pipe_enable,
    .update  = my_pipe_update,
};

/* --- DRM Driver --- */
DEFINE_DRM_GEM_FOPS(my_fops);

static const struct drm_driver my_driver = {
    .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
    .fops            = &my_fops,
    DRM_GEM_SHMEM_DRIVER_OPS,
    .name  = "my-display",
    .desc  = "My simple display driver",
    .date  = "20260101",
    .major = 1,
    .minor = 0,
};

/* --- Platform Driver --- */
static int my_probe(struct platform_device *pdev)
{
    struct my_drm *my;
    struct drm_device *drm;
    static const uint32_t formats[] = { DRM_FORMAT_XRGB8888 };
    int ret;

    my = devm_drm_dev_alloc(&pdev->dev, &my_driver,
                            struct my_drm, drm);
    if (IS_ERR(my))
        return PTR_ERR(my);
    drm = &my->drm;

    /* MMIO 매핑 */
    my->regs = devm_platform_ioremap_resource(pdev, 0);
    if (IS_ERR(my->regs))
        return PTR_ERR(my->regs);

    /* Connector 초기화 */
    drm_connector_init(drm, &my->connector,
                       &my_conn_funcs, DRM_MODE_CONNECTOR_Unknown);
    drm_connector_helper_add(&my->connector, &my_conn_helpers);

    /* Simple display pipe 초기화 (CRTC+Plane+Encoder 한 번에) */
    ret = drm_simple_display_pipe_init(drm, &my->pipe,
            &my_pipe_funcs, formats, ARRAY_SIZE(formats),
            NULL, &my->connector);
    if (ret)
        return ret;

    drm_mode_config_reset(drm);
    ret = drm_dev_register(drm, 0);
    if (ret)
        return ret;

    /* fbdev 에뮬레이션 (콘솔 출력) */
    drm_fbdev_shmem_setup(drm, 32);
    return 0;
}

MODULE_LICENSE("GPL");

주요 오픈소스 DRM 드라이버

최근 DRM 코어의 방향

버전 번호 자체보다 중요한 것은 메인라인이 어떤 설계 축으로 이동하는가입니다. 최근 DRM 문서와 헤더를 보면 다음 네 가지 흐름이 거의 모든 드라이버 설계에 공통으로 반영됩니다.

DRM Bridge & Panel 프레임워크

임베디드/모바일 SoC에서는 디스플레이 출력이 여러 개의 하드웨어 블록 체인으로 구성됩니다. drm_bridge는 이 체인의 중간 단계(MIPI-DSI to HDMI 변환기, LVDS 직렬화(Serialization)기 등)를, drm_panel은 최종 디스플레이 패널을 추상화합니다.

/* DRM Bridge 드라이버 구현 예시 */
#include <drm/drm_bridge.h>

static const struct drm_bridge_funcs my_bridge_funcs = {
    /* 디스플레이 파이프라인 활성화 순서 */
    .pre_enable  = my_bridge_pre_enable,  /* PLL/클럭 설정 */
    .enable      = my_bridge_enable,      /* 출력 활성화 */
    .disable     = my_bridge_disable,
    .post_disable = my_bridge_post_disable,

    /* 모드 검증 */
    .mode_valid  = my_bridge_mode_valid,  /* 지원 해상도 필터링 */
    .mode_fixup  = my_bridge_mode_fixup,  /* adjusted_mode 수정 */

    /* Atomic 지원 (권장) */
    .atomic_pre_enable = my_bridge_atomic_pre_enable,
    .atomic_enable     = my_bridge_atomic_enable,
    .atomic_disable    = my_bridge_atomic_disable,

    /* 출력 감지 (DRM_BRIDGE_OP_DETECT) */
    .detect      = my_bridge_detect,
    .get_modes   = my_bridge_get_modes,   /* EDID 기반 모드 목록 */
    .get_edid    = my_bridge_get_edid,    /* EDID 읽기 */
};

static int my_bridge_probe(struct i2c_client *client)
{
    struct my_bridge *mb = devm_kzalloc(&client->dev, sizeof(*mb), GFP_KERNEL);

    mb->bridge.funcs = &my_bridge_funcs;
    mb->bridge.of_node = client->dev.of_node;
    mb->bridge.type = DRM_MODE_CONNECTOR_HDMIA;  /* 출력 커넥터 타입 */
    mb->bridge.ops = DRM_BRIDGE_OP_DETECT |
                     DRM_BRIDGE_OP_EDID |
                     DRM_BRIDGE_OP_MODES;

    drm_bridge_add(&mb->bridge);
    return 0;
}

/* DRM Panel 드라이버 구현 예시 */
#include <drm/drm_panel.h>

static const struct drm_panel_funcs my_panel_funcs = {
    .prepare    = my_panel_prepare,     /* 전원 ON, 리셋 해제 */
    .enable     = my_panel_enable,      /* 백라이트 ON, 디스플레이 ON */
    .disable    = my_panel_disable,     /* 백라이트 OFF */
    .unprepare  = my_panel_unprepare,   /* 전원 OFF */
    .get_modes  = my_panel_get_modes,   /* 고정 모드 반환 */
};

static int my_panel_probe(struct mipi_dsi_device *dsi)
{
    struct my_panel *panel = devm_kzalloc(&dsi->dev, sizeof(*panel), GFP_KERNEL);

    drm_panel_init(&panel->panel, &dsi->dev, &my_panel_funcs,
                   DRM_MODE_CONNECTOR_DSI);
    drm_panel_add(&panel->panel);
    return 0;
}

/* 디스플레이 드라이버에서 bridge + panel 연결 */
struct drm_bridge *bridge;
bridge = devm_drm_of_get_bridge(dev, dev->of_node, 0, 0);
/* drm_panel은 자동으로 panel-bridge로 래핑됨 */
drm_bridge_attach(encoder, bridge, NULL, DRM_BRIDGE_ATTACH_NO_CONNECTOR);

/* 체인의 마지막 bridge에서 connector 생성 */
connector = drm_bridge_connector_init(drm, encoder);

DRM ioctl 요약

DRM Lease (디스플레이 리스)

DRM Lease는 DRM Master가 자신의 KMS 리소스(CRTC, Connector, Plane) 일부를 다른 프로세스에게 독점적으로 위임하는 메커니즘입니다. VR 헤드셋, 멀티시트 디스플레이, 게임 전용 출력 등에서 사용됩니다.

/* DRM Lease 생성 (유저 공간, libdrm) */
uint32_t objects[] = {
    crtc_id,       /* 리스할 CRTC */
    connector_id,  /* 리스할 Connector */
    plane_id,      /* 리스할 Plane */
};

struct drm_mode_create_lease lease = {
    .object_ids   = (uint64_t)(uintptr_t)objects,
    .object_count = 3,
    .flags        = O_CLOEXEC | O_NONBLOCK,
};

drmIoctl(master_fd, DRM_IOCTL_MODE_CREATE_LEASE, &lease);
/* lease.lessee_id = 리스 ID */
/* lease.fd = lessee가 사용할 새 DRM fd */

/* Lessee는 lease.fd를 통해 리스된 오브젝트만 접근 가능 */
/* → 독립적인 atomic commit, 페이지 플립 수행 */

Content Protection (HDCP)

HDCP(High-bandwidth Digital Content Protection)는 디스플레이 출력의 콘텐츠를 암호화(Encryption)하여 무단 복제를 방지하는 DRM(Digital Rights Management) 기술입니다. Linux DRM 서브시스템은 KMS property를 통해 HDCP를 지원합니다.

/* HDCP KMS Properties (Connector) */

/* "Content Protection" property */
/* 값: Undesired (0) → Desired (1) → Enabled (2) */
/*     유저가 Desired로 설정하면 드라이버가 HDCP 인증 시작 */
/*     성공 시 Enabled로 전환 (읽기 전용) */

/* "HDCP Content Type" property */
/* 값: Type 0 — HDCP 1.4+ 허용 */
/*     Type 1 — HDCP 2.2+ 필수 (4K UHD 콘텐츠) */

/* Connector에 HDCP property 등록 (드라이버) */
drm_connector_attach_content_protection_property(connector, true);
/* true = HDCP Content Type property도 함께 등록 */

/* HDCP 인증 흐름 (드라이버 내부) */
/* 1. 유저가 "Content Protection" = Desired 설정 */
/* 2. atomic_check에서 HDCP 요청 감지 */
/* 3. 드라이버가 수신기(모니터)와 HDCP 핸드셰이크 */
/*    - AKE_Init / AKE_Send_Cert / AKE_Send_Km ... */
/* 4. 인증 성공 → "Content Protection" = Enabled */
/* 5. 링크 실패/핫플러그 → "Content Protection" = Desired */
/*    → 유저 공간에 uevent 통보 → 재인증 시도 */

디스플레이 연결 프로토콜

DisplayPort MST (Multi-Stream Transport)

DP MST는 하나의 DP 출력에서 여러 디스플레이를 데이지 체인으로 연결하거나 MST 허브를 통해 분기하는 기술입니다. 커널은 drm_dp_mst_topology_mgr로 MST 토폴로지(Topology)를 관리합니다.

/* MST 토폴로지 매니저 초기화 (드라이버) */
drm_dp_mst_topology_mgr_init(&my->mst_mgr, &my->aux,
    16,   /* 최대 페이로드 수 */
    4,    /* 최대 레인 수 */
    conn_base_id);

/* MST 허브 감지 시 (HPD IRQ에서) */
drm_dp_mst_hpd_irq_handle_event(&my->mst_mgr, esi);
/* → 토폴로지 변경 시 connector 추가/제거 이벤트 */

/* MST 대역폭 계산 예시 */
/* DP 1.4 HBR3: 8.1 Gbps/레인 × 4 레인 = 32.4 Gbps 총 대역폭 */
/* 4K@60Hz (XRGB8888): ~12.5 Gbps 필요 → 63개 시간 슬롯 중 ~25개 사용 */
/* 나머지 슬롯으로 2번째 모니터 (FHD@60Hz) 연결 가능 */

DSC (Display Stream Compression)

DSC는 VESA가 표준화한 시각적 무손실(visually lossless) 디스플레이 압축입니다. 고해상도(8K, 4K@120Hz+)에서 DP/HDMI 대역폭 한계를 극복하기 위해 사용됩니다. Linux DRM에서는 drm_dsc_config로 DSC 파라미터를 관리합니다.

/* DSC 설정 예시 (드라이버 atomic_check에서) */
struct drm_dsc_config dsc_cfg = {};

dsc_cfg.line_buf_depth     = 13;
dsc_cfg.bits_per_component = 8;
dsc_cfg.bits_per_pixel     = 128;    /* 8 bpp × 16 (4비트 소수부) */
dsc_cfg.slice_width        = 1920;  /* 슬라이스 너비 */
dsc_cfg.slice_height       = 108;   /* 슬라이스 높이 */
dsc_cfg.pic_width          = 3840;
dsc_cfg.pic_height         = 2160;

/* RC (Rate Control) 파라미터 자동 계산 */
drm_dsc_compute_rc_parameters(&dsc_cfg);

/* PPS (Picture Parameter Set) 생성 → DP SDP 또는 HDMI infoframe으로 전송 */
drm_dsc_pps_payload_pack(pps_payload, &dsc_cfg);

fbdev 에뮬레이션

DRM/KMS는 /dev/fb0 (fbdev) 인터페이스를 에뮬레이션하여 레거시 애플리케이션(fbcon, Plymouth 등)과 콘솔 출력을 지원합니다. drm_fbdev_shmem, drm_fbdev_ttm, drm_fbdev_dma 등의 헬퍼가 GEM/TTM 버퍼를 fb_info에 연결하고, DRM atomic 경로로 브리지(Bridge)합니다.

참고 사항

관련 문서

이 주제와 관련된 다른 문서를 더 깊이 이해하고 싶다면 다음을 참고하세요.

• GPU 서브시스템 (DRM/KMS) 개요 — GPU 서브시스템 전체 구조와 핵심 요약
• GPU 메모리 관리 및 스케줄러 — GEM/TTM, DMA-BUF, GPU 스케줄러, GPUVM, 전원 관리
• GPU 컴퓨팅 — CUDA, OpenCL, Vulkan Compute, ROCm/HIP, Intel oneAPI
• 디바이스 드라이버 — 디바이스 드라이버 모델, DMA, IRQ
• PCI / PCIe — PCI/PCIe 버스 아키텍처
• 프레임버퍼 (fbdev) — fbdev 서브시스템 상세
• 전원 관리 — 디바이스 전원 관리