GPU 서브시스템 (DRM/KMS)

Linux 커널 GPU 서브시스템: DRM/KMS 아키텍처, GEM/TTM 메모리 관리, DMA-BUF 버퍼 공유, GPU 스케줄러, Atomic Modesetting, DRM 드라이버 구조 종합 가이드.

DRM (Direct Rendering Manager) 개요

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

DRM 아키텍처

DRM 핵심 구조체

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 (파일 프라이빗)

유저 프로세스가 /dev/dri/card0를 open하면 drm_file 구조체가 생성됩니다. 프로세스별 GPU 컨텍스트, 인증 상태, GEM 핸들 테이블을 관리합니다.

/* drm_file 주요 필드 (include/drm/drm_file.h) */
struct drm_file {
    struct drm_device  *minor;        /* 소속 DRM 디바이스 */
    bool               authenticated; /* DRM Master 인증 여부 */
    struct idr         object_idr;    /* GEM 핸들 → drm_gem_object 매핑 */
    struct list_head   event_list;    /* 페이지 플립 등 이벤트 큐 */
    void              *driver_priv;   /* 드라이버별 프라이빗 데이터 */
};

KMS (Kernel Mode Setting)

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

KMS 핵심 오브젝트

Atomic Modesetting

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

/* 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, ...);

GEM (Graphics Execution Manager) 메모리 관리

GEM은 GPU 메모리 버퍼 객체를 관리하는 프레임워크입니다. 유저 공간에서는 정수 핸들로 버퍼를 참조하고, 커널은 내부적으로 drm_gem_object로 관리합니다.

/* GEM 객체 구조 (include/drm/drm_gem.h) */
struct drm_gem_object {
    struct drm_device     *dev;          /* 소속 디바이스 */
    struct file           *filp;         /* shmem backing store */
    size_t                size;          /* 버퍼 크기 */
    struct kref           refcount;      /* 참조 카운팅 */
    uint32_t              name;          /* flink 이름 (레거시) */
    struct dma_buf        *dma_buf;      /* DMA-BUF 익스포트 시 */
    const struct drm_gem_object_funcs *funcs;
};

/* GEM 오퍼레이션 콜백 */
struct drm_gem_object_funcs {
    void (*free)(struct drm_gem_object *obj);
    int  (*open)(struct drm_gem_object *obj, struct drm_file *file);
    void (*close)(struct drm_gem_object *obj, struct drm_file *file);
    int  (*pin)(struct drm_gem_object *obj);
    int  (*vmap)(struct drm_gem_object *obj, struct iosys_map *map);
    struct sg_table *(*get_sg_table)(struct drm_gem_object *obj);
};

GEM 버퍼 생명주기

GEM SHMEM 헬퍼

대부분의 임베디드/모바일 GPU 드라이버는 drm_gem_shmem_object를 사용합니다. 시스템 메모리(shmem)에 버퍼를 할당하며, CMA(Contiguous Memory Allocator) 통합도 지원합니다.

#include <drm/drm_gem_shmem_helper.h>

/* GEM SHMEM 기반 드라이버의 dumb_create 구현 */
static int my_dumb_create(struct drm_file *file,
                           struct drm_device *dev,
                           struct drm_mode_create_dumb *args)
{
    /* pitch 정렬 (하드웨어 요구사항에 맞춤) */
    args->pitch = ALIGN(args->width * DIV_ROUND_UP(args->bpp, 8), 64);
    args->size  = args->pitch * args->height;

    /* shmem 헬퍼가 할당 + 핸들 반환 */
    return drm_gem_shmem_dumb_create(file, dev, args);
}

/* 드라이버에서 vmap으로 커널 가상 주소 획득 */
struct drm_gem_shmem_object *shmem = to_drm_gem_shmem_obj(gem_obj);
struct iosys_map map;
drm_gem_shmem_vmap(shmem, &map);
/* map.vaddr로 커널에서 버퍼 접근 */

TTM (Translation Table Manager)

TTM은 전용 VRAM(비디오 메모리)이 있는 GPU를 위한 메모리 관리자입니다. 버퍼를 VRAM과 시스템 메모리 사이에서 이동(eviction/migration)시키는 고급 기능을 제공합니다.

/* TTM 메모리 도메인 (placement) */
struct ttm_place {
    uint32_t  mem_type;   /* TTM_PL_SYSTEM, TTM_PL_VRAM, TTM_PL_TT */
    uint32_t  flags;      /* TTM_PL_FLAG_CONTIGUOUS 등 */
    uint64_t  fpfn;       /* 시작 페이지 프레임 번호 */
    uint64_t  lpfn;       /* 끝 페이지 프레임 번호 (0=제한 없음) */
};

/* TTM 버퍼 오브젝트 주요 필드 */
struct ttm_buffer_object {
    struct drm_gem_object    base;         /* GEM 상속 */
    struct ttm_device        *bdev;         /* TTM 디바이스 */
    struct ttm_resource      *resource;     /* 현재 메모리 위치 */
    struct ttm_placement     placement;     /* 선호 도메인 */
    struct ttm_tt            *ttm;          /* 시스템 메모리 페이지 */
};

/* TTM 메모리 도메인 상수 */
#define TTM_PL_SYSTEM  0  /* 시스템 RAM (커널 관리) */
#define TTM_PL_TT      1  /* GART/GTT 매핑된 시스템 메모리 */
#define TTM_PL_VRAM    2  /* 디바이스 전용 비디오 메모리 */

DMA-BUF (버퍼 공유)

DMA-BUF는 디바이스 간 버퍼 공유를 위한 커널 프레임워크입니다. GPU에서 렌더링한 버퍼를 디스플레이 컨트롤러, 비디오 인코더, 카메라 등 다른 디바이스와 복사 없이 공유할 수 있습니다.

/* DMA-BUF exporter 오퍼레이션 (드라이버 구현) */
static const struct dma_buf_ops my_dmabuf_ops = {
    .attach         = my_dmabuf_attach,       /* importer 디바이스 등록 */
    .detach         = my_dmabuf_detach,
    .map_dma_buf    = my_dmabuf_map,          /* sg_table 반환 (DMA 주소) */
    .unmap_dma_buf  = my_dmabuf_unmap,
    .release        = my_dmabuf_release,      /* 버퍼 해제 */
    .mmap           = my_dmabuf_mmap,         /* 유저 공간 매핑 */
    .vmap           = my_dmabuf_vmap,         /* 커널 가상 주소 매핑 */
};

/* GEM → DMA-BUF export (PRIME) */
struct dma_buf *dmabuf = drm_gem_prime_export(gem_obj, flags);
/* → 유저 공간에서 fd = DRM_IOCTL_PRIME_HANDLE_TO_FD(handle) */

/* DMA-BUF → GEM import (PRIME) */
struct drm_gem_object *obj = drm_gem_prime_import(dev, dmabuf);
/* → 유저 공간에서 handle = DRM_IOCTL_PRIME_FD_TO_HANDLE(fd) */

dma_fence & dma_resv (동기화)

GPU 작업은 비동기로 실행되므로, 버퍼를 공유하는 디바이스들은 작업 완료를 동기화해야 합니다.

/* Fence 기본 사용 패턴 */
struct dma_fence *fence;

/* GPU 작업 제출 시 fence 생성 */
fence = my_gpu_submit_job(job);

/* 버퍼의 reservation object에 fence 등록 */
dma_resv_add_fence(bo->base.resv, fence, DMA_RESV_USAGE_WRITE);

/* 다른 디바이스가 이 버퍼를 사용하기 전에 대기 */
ret = dma_resv_wait_timeout(bo->base.resv, DMA_RESV_USAGE_WRITE,
                            true, msecs_to_jiffies(5000));

/* Fence 시그널 (GPU 인터럽트 핸들러에서 호출) */
dma_fence_signal(fence);
dma_fence_put(fence);

GPU 커맨드 서브미션

GPU 렌더링 작업은 커맨드 버퍼(command buffer)를 통해 제출됩니다. 유저 공간(Mesa/Vulkan 드라이버)이 GPU 명령어를 버퍼에 기록하고, 커널 드라이버가 이를 GPU 하드웨어에 전달합니다.

서브미션 모델 비교

/* amdgpu 커맨드 서브미션 예시 (유저 공간, libdrm_amdgpu) */
struct amdgpu_cs_request cs_req = {};
struct amdgpu_cs_ib_info ib_info = {
    .ib_mc_address = ib_gpu_addr,  /* IB의 GPU 가상 주소 */
    .size          = ib_size_dw,   /* 더블워드 단위 크기 */
};
cs_req.ip_type       = AMDGPU_HW_IP_GFX;   /* GFX 엔진 */
cs_req.number_of_ibs = 1;
cs_req.ibs           = &ib_info;

/* 의존 fence 목록 (이전 작업 완료 대기) */
struct amdgpu_cs_fence_info fence_info = { ... };
cs_req.fence_info = fence_info;

/* 서브미션 */
amdgpu_cs_submit(ctx, 0, &cs_req, 1);

/* 완료 대기 (선택적) */
struct amdgpu_cs_fence fence = {
    .context = ctx,
    .ip_type = AMDGPU_HW_IP_GFX,
    .fence   = cs_req.seq_no,
};
amdgpu_cs_query_fence_status(&fence, timeout_ns, 0, &expired);

/* 커널 드라이버의 커맨드 서브미션 검증 (보안상 중요) */

/* 1. 버퍼 오브젝트 유효성 */
/*    - 유저가 전달한 GEM 핸들이 실제 소유인지 확인 */
/*    - BO가 올바른 메모리 도메인에 있는지 확인 */

/* 2. 커맨드 파싱 (일부 드라이버) */
/*    - 금지된 GPU 레지스터 접근 차단 */
/*    - 다른 프로세스의 GPU 주소 공간 접근 방지 */
/*    - 최신 GPU는 하드웨어 격리 (per-context page table)로 대체 */

/* 3. 의존성 처리 */
/*    - 공유 BO의 dma_resv에서 기존 fence 확인 */
/*    - 의존 fence를 drm_sched_job의 dependency로 등록 */
/*    - 모든 의존 fence가 시그널된 후에만 GPU에 제출 */

/* 4. fence 등록 */
/*    - 새 작업의 fence를 사용 BO의 dma_resv에 추가 */
/*    - explicit sync: fence를 sync_file fd로 유저에게 반환 */

GPU 스케줄러 (drm_sched)

DRM GPU 스케줄러(drivers/gpu/drm/scheduler/)는 여러 프로세스의 GPU 작업을 공정하게 스케줄링하고, GPU 행(hang) 감지 및 복구를 처리합니다.

#include <drm/gpu_scheduler.h>

/* 스케줄러 초기화 (드라이버 probe에서) */
struct drm_gpu_scheduler sched;

drm_sched_init(&sched,
    &my_sched_ops,              /* 드라이버 콜백 */
    NULL,                       /* workqueue (NULL=기본) */
    num_hw_rings,               /* 하드웨어 큐 수 */
    0,                          /* credit limit */
    msecs_to_jiffies(10000),   /* 타임아웃 (10초) */
    NULL,                       /* workqueue for timeout */
    NULL,                       /* score */
    "my-gpu",                   /* 이름 */
    dev->dev);

/* 스케줄러 오퍼레이션 */
static const struct drm_sched_backend_ops my_sched_ops = {
    .run_job    = my_run_job,        /* GPU에 작업 제출 */
    .timedout_job = my_timedout_job, /* 타임아웃 시 GPU 리셋 */
    .free_job   = my_free_job,       /* 완료된 작업 해제 */
};

/* run_job 구현 예시 */
static struct dma_fence *my_run_job(struct drm_sched_job *job)
{
    struct my_job *mj = to_my_job(job);

    /* GPU 하드웨어 레지스터에 커맨드 버퍼 주소 기록 */
    writel(mj->cmd_buf_addr, gpu->regs + CMD_SUBMIT);

    /* 완료 fence 반환 (GPU 인터럽트에서 시그널) */
    return dma_fence_get(mj->fence);
}

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 Bridge & Panel 프레임워크

임베디드/모바일 SoC에서는 디스플레이 출력이 여러 개의 하드웨어 블록 체인으로 구성됩니다. drm_bridge는 이 체인의 중간 단계(MIPI-DSI to HDMI 변환기, LVDS 직렬화기 등)를, 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);

GPU 가상 메모리 (GPUVM)

현대 GPU는 자체 MMU를 가지며, 프로세스별 독립적인 GPU 가상 주소 공간을 제공합니다. 커널 DRM 프레임워크는 drm_gpuvm(drivers/gpu/drm/drm_gpuvm.c)으로 이를 추상화합니다.

/* GPU 가상 주소 공간 개념 */

/*
 * CPU 가상 메모리와 유사한 구조:
 *
 * Process A의 GPU VA 공간    Process B의 GPU VA 공간
 * ┌──────────────────┐      ┌──────────────────┐
 * │ 0x0000_0000_0000 │      │ 0x0000_0000_0000 │
 * │ (unmapped)       │      │ (unmapped)       │
 * ├──────────────────┤      ├──────────────────┤
 * │ 0x0001_0000_0000 │      │ 0x0001_0000_0000 │
 * │ Shader Code      │─┐    │ Shader Code      │─┐
 * ├──────────────────┤ │    ├──────────────────┤ │
 * │ 0x0002_0000_0000 │ │    │ 0x0002_0000_0000 │ │
 * │ Vertex Buffer    │ │    │ Texture Data     │ │
 * ├──────────────────┤ │    ├──────────────────┤ │
 * │ ...              │ │    │ ...              │ │
 * └──────────────────┘ │    └──────────────────┘ │
 *                      ▼                         ▼
 *              ┌──────────────────────────┐
 *              │   GPU MMU (Page Tables)  │
 *              │   GPU VA → Physical Addr │
 *              └──────────────────────────┘
 *                      │
 *              ┌───────┴────────┐
 *              ▼                ▼
 *       ┌──────────┐   ┌──────────┐
 *       │  VRAM    │   │ System   │
 *       │          │   │ Memory   │
 *       └──────────┘   └──────────┘
 */

/* drm_gpuvm 주요 구조체 */
struct drm_gpuvm {
    const char              *name;
    struct drm_device       *drm;
    struct rb_root_cached   rb;     /* GPU VA 매핑 레드-블랙 트리 */
    u64 mm_start, mm_range;          /* 관리 범위 */
};

/* GPU VA 매핑 하나 */
struct drm_gpuva {
    u64 va_start, va_range;           /* GPU 가상 주소 범위 */
    struct drm_gem_object *gem_obj;   /* 백업 GEM 객체 */
    u64 gem_offset;                   /* GEM 내 오프셋 */
};

GPU 전원 관리

GPU는 시스템에서 가장 전력을 많이 소비하는 디바이스 중 하나이므로, 정교한 전원 관리가 필수적입니다.

# GPU Runtime PM 상태 확인
cat /sys/class/drm/card0/device/power/runtime_status
# active / suspended / suspending

# Runtime PM 자동 절전 지연 설정 (밀리초)
echo 5000 > /sys/class/drm/card0/device/power/autosuspend_delay_ms

# GPU 클럭 주파수 확인 (amdgpu 예시)
cat /sys/class/drm/card0/device/pp_dpm_sclk
# 0: 300Mhz
# 1: 600Mhz *
# 2: 900Mhz

# PRIME GPU 오프로드 (외장 GPU로 렌더링)
DRI_PRIME=1 glxinfo | grep "OpenGL renderer"

# vga_switcheroo 상태 (하이브리드 GPU)
cat /sys/kernel/debug/vgaswitcheroo/switch

GPU 리셋 및 복구

GPU는 잘못된 셰이더, 무한 루프, 하드웨어 결함 등으로 응답 불능(hang) 상태에 빠질 수 있습니다. DRM 프레임워크는 hang 감지, GPU 리셋, 작업 재제출의 3단계 복구 메커니즘을 제공합니다.

Hang 감지

리셋 수준

/* GPU 리셋 수준 (세밀한 것부터 거친 순서) */

/* Level 1: Per-engine 리셋 (권장, 최소 영향) */
/* 특정 GPU 엔진(GFX, SDMA, 비디오 등)만 리셋 */
/* 다른 엔진은 계속 동작 */
amdgpu_device_reset_engine(adev, ring);  /* amdgpu 예시 */

/* Level 2: Per-context 리셋 (하드웨어 지원 필요) */
/* 특정 GPU 컨텍스트만 무효화 */
/* i915: 잘못된 컨텍스트를 ban (금지) 처리 */
intel_context_ban(ce, NULL);

/* Level 3: 전체 GPU 리셋 */
/* 모든 엔진/컨텍스트 중단 후 GPU 완전 재초기화 */
amdgpu_device_gpu_recover(adev, NULL, false);

/* Level 4: FLR (Function Level Reset) - PCIe */
/* PCIe 레벨에서 디바이스 전체 리셋 */
pci_reset_function(pdev);

/* Level 5: BACO (Bus Active, Chip Off) - AMD */
/* GPU 전원을 완전히 차단 후 재투입 */
amdgpu_device_baco_enter(adev_to_drm(adev));
amdgpu_device_baco_exit(adev_to_drm(adev));

복구 흐름

/* drm_sched 타임아웃 → 복구 흐름 */

/* 1. 타임아웃 콜백 호출 */
static enum drm_gpu_sched_stat
my_timedout_job(struct drm_sched_job *job)
{
    struct my_device *dev = job_to_dev(job);

    /* 2. GPU 상태 덤프 (디버깅용) */
    dev_coredump_snapshot(dev);  /* devcoredump 프레임워크 */

    /* 3. GPU 리셋 수행 */
    my_gpu_reset(dev);

    /* 4. 스케줄러에 리셋 완료 통보 */
    /*    → 대기 중인 fence들을 에러로 시그널 */
    /*    → guilty 작업의 entity에 guilty 플래그 설정 */
    return DRM_GPU_SCHED_STAT_NOMINAL;
}

/* 5. 유저 공간 알림 */
/*    - 리셋 후 fence가 에러(-EIO)로 시그널됨 */
/*    - Vulkan: VK_ERROR_DEVICE_LOST 반환 */
/*    - GL: GL_CONTEXT_LOST 또는 glGetGraphicsResetStatusARB() */
/*    - amdgpu: AMDGPU_CTX_QUERY2 ioctl로 리셋 감지 */

# GPU 리셋 관련 sysfs/debugfs

# amdgpu: 수동 GPU 복구 트리거
echo 1 > /sys/kernel/debug/dri/0/amdgpu_gpu_recover

# i915: 엔진 리셋 카운트
cat /sys/kernel/debug/dri/0/i915_reset_info

# devcoredump: GPU 상태 덤프 읽기
cat /sys/class/devcoredump/devcd0/data > gpu_dump.bin

# devcoredump 삭제 (5분 후 자동 삭제)
echo 1 > /sys/class/devcoredump/devcd0/data

# dmesg에서 GPU 리셋 로그 확인
dmesg | grep -i "gpu\|reset\|hang\|timed out"

커널 설정 (Kconfig)

# DRM 핵심 설정
CONFIG_DRM=m                      # DRM 코어 모듈
CONFIG_DRM_KMS_HELPER=m           # KMS 헬퍼 함수
CONFIG_DRM_GEM_SHMEM_HELPER=m     # GEM shmem 헬퍼
CONFIG_DRM_SCHED=m                # GPU 스케줄러
CONFIG_DRM_TTM=m                  # TTM 메모리 관리자
CONFIG_DRM_DISPLAY_HELPER=m       # DP/HDMI 디스플레이 헬퍼

# 드라이버별 설정
CONFIG_DRM_I915=m                 # Intel i915
CONFIG_DRM_XE=m                   # Intel Xe
CONFIG_DRM_AMDGPU=m               # AMD GPU
CONFIG_DRM_NOUVEAU=m              # NVIDIA (오픈소스)
CONFIG_DRM_PANFROST=m             # ARM Mali (Midgard/Bifrost)
CONFIG_DRM_LIMA=m                 # ARM Mali (Utgard)
CONFIG_DRM_VC4=m                  # Broadcom VideoCore
CONFIG_DRM_MSM=m                  # Qualcomm Adreno
CONFIG_DRM_VIRTIO_GPU=m           # 가상 GPU (QEMU)
CONFIG_DRM_SIMPLEDRM=y            # EFI/BIOS 프레임버퍼

# fbdev 에뮬레이션 (DRM 위에서 /dev/fb0 제공)
CONFIG_DRM_FBDEV_EMULATION=y

# DMA-BUF
CONFIG_DMA_SHARED_BUFFER=y

DRM 디버깅

디버깅 도구

커널 디버그 메시지

# DRM 디버그 레벨 설정 (비트마스크)
echo 0x1ff > /sys/module/drm/parameters/debug

# 비트마스크 의미:
#   0x001 = DRM_UT_CORE     — DRM 코어
#   0x002 = DRM_UT_DRIVER   — 드라이버
#   0x004 = DRM_UT_KMS      — 모드 설정
#   0x008 = DRM_UT_PRIME    — PRIME/DMA-BUF
#   0x010 = DRM_UT_ATOMIC   — Atomic modesetting
#   0x020 = DRM_UT_VBL      — Vblank
#   0x040 = DRM_UT_STATE    — Atomic 상태
#   0x080 = DRM_UT_LEASE    — DRM 리스
#   0x100 = DRM_UT_DP       — DisplayPort
#   0x200 = DRM_UT_DRMRES   — 리소스 관리

# 부팅 시 커널 파라미터로 설정
# drm.debug=0x1e (DRIVER+KMS+PRIME+ATOMIC)

# DRM debugfs 정보 확인
ls /sys/kernel/debug/dri/0/
# clients  gem_names  name  state  ...

# GEM 객체 목록 (메모리 사용량 확인)
cat /sys/kernel/debug/dri/0/gem_names

# 현재 KMS 상태 (모든 CRTC/Plane/Connector)
cat /sys/kernel/debug/dri/0/state

# GPU 행(hang) 시 ftrace로 추적
echo 1 > /sys/kernel/debug/tracing/events/drm/enable
cat /sys/kernel/debug/tracing/trace_pipe

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)는 디스플레이 출력의 콘텐츠를 암호화하여 무단 복제를 방지하는 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 통보 → 재인증 시도 */

디스플레이 연결 프로토콜

fbdev 에뮬레이션

DRM/KMS는 /dev/fb0 (fbdev) 인터페이스를 에뮬레이션하여 레거시 애플리케이션과 콘솔 출력을 지원합니다. 커널 콘솔(fbcon), Plymouth(부팅 스플래시), 일부 임베디드 UI 프레임워크가 fbdev에 의존합니다.

/* fbdev 에뮬레이션 구조 */

/*
 * ┌─────────────────────────────────┐
 * │  User Space (/dev/fb0)          │
 * │  - fbcon (커널 콘솔)             │
 * │  - mmap()으로 프레임버퍼 직접 접근  │
 * └──────────┬──────────────────────┘
 *            │ fb_ops
 * ┌──────────▼──────────────────────┐
 * │  DRM fbdev 에뮬레이션 레이어     │
 * │  drm_fbdev_shmem / drm_fbdev_ttm│
 * │  - GEM 객체를 fb_info에 매핑     │
 * │  - fb_dirty()로 변경 영역 통보   │
 * └──────────┬──────────────────────┘
 *            │ KMS atomic commit
 * ┌──────────▼──────────────────────┐
 * │  DRM/KMS (CRTC + Plane + ...)   │
 * └─────────────────────────────────┘
 */

/* 드라이버에서 fbdev 에뮬레이션 활성화 */
#include <drm/drm_fbdev_shmem.h>

static int my_probe(struct platform_device *pdev)
{
    /* ... DRM 초기화 ... */

    /* fbdev 에뮬레이션 설정 (32 = bpp) */
    drm_fbdev_shmem_setup(drm, 32);
    /* → /dev/fb0 자동 생성 */
    /* → fbcon 자동 연결 (CONFIG_FRAMEBUFFER_CONSOLE) */
}

GPU 컴퓨트 (GPGPU)

GPU는 렌더링 외에도 대규모 병렬 연산(GPGPU)에 사용됩니다. Linux 커널은 render node(/dev/dri/renderD128)를 통해 비특권 GPU 컴퓨트 접근을 제공하며, AMD는 KFD(Kernel Fusion Driver)로 HSA 컴퓨트를 추가 지원합니다.

KFD (Kernel Fusion Driver) — AMD HSA

/* KFD 아키텍처 (drivers/gpu/drm/amd/amdkfd/) */

/*
 * /dev/kfd — AMD GPU 컴퓨트 전용 디바이스 노드
 *
 * ┌────────────────────────┐
 * │  ROCm Runtime / HIP    │  User Space
 * │  (libhsakmt, HSA RT)   │
 * └──────────┬─────────────┘
 *            │ KFD ioctl
 * ┌──────────▼─────────────┐
 * │  KFD (amdkfd)          │  Kernel
 * │  - 프로세스별 GPU 큐 관리 │
 * │  - SVM (Shared Virtual  │
 * │    Memory) 관리          │
 * │  - GPU 이벤트/시그널     │
 * └──────────┬─────────────┘
 *            │
 * ┌──────────▼─────────────┐
 * │  amdgpu DRM 드라이버    │
 * │  (하드웨어 접근)         │
 * └────────────────────────┘
 */

/* KFD 주요 ioctl */
KFD_IOC_CREATE_QUEUE       /* GPU 컴퓨트 큐 생성 (AQL 형식) */
KFD_IOC_DESTROY_QUEUE      /* 큐 삭제 */
KFD_IOC_ALLOC_MEMORY_OF_GPU /* GPU 메모리 할당 (VRAM/GTT/System) */
KFD_IOC_MAP_MEMORY_TO_GPU   /* GPU 페이지 테이블에 메모리 매핑 */
KFD_IOC_CREATE_EVENT       /* GPU 이벤트 생성 (완료 통보) */
KFD_IOC_WAIT_EVENTS        /* GPU 이벤트 대기 */
KFD_IOC_SVM                /* SVM 범위 등록/속성 설정 */

SVM (Shared Virtual Memory)

SVM은 CPU와 GPU가 동일한 가상 주소 공간을 공유하는 기술입니다. malloc()으로 할당한 메모리를 GPU가 동일한 포인터로 접근할 수 있습니다.

/* SVM 개념 */
/*
 * CPU Process VA Space
 * ┌──────────────────────────┐
 * │ 0x7fff_xxxx: Stack       │
 * │ ...                      │
 * │ 0x0040_0000: Code        │
 * │ 0x1000_0000: malloc buf ←┼── CPU가 이 주소로 접근
 * └──────────────────────────┘
 *                               │
 *                               ▼ 동일한 가상 주소
 * GPU VA Space                  │
 * ┌──────────────────────────┐  │
 * │ 0x1000_0000: malloc buf ←┼──┘ GPU도 이 주소로 접근
 * └──────────────────────────┘
 *
 * 구현:
 * - GPU 페이지 테이블을 CPU 페이지 테이블과 동기화
 * - GPU 페이지 폴트 발생 시 on-demand 페이징
 * - HMM (Heterogeneous Memory Management) 프레임워크 활용
 * - MMU notifier로 CPU 페이지 테이블 변경 추적
 */

/* 커널 SVM 지원 (amdgpu/KFD) */
#include <linux/hmm.h>

/* GPU 페이지 폴트 핸들러 */
/* 1. GPU가 매핑되지 않은 주소 접근 → 인터럽트 */
/* 2. 커널이 CPU 페이지 테이블에서 물리 주소 조회 */
/*    (페이지 없으면 CPU 페이지 폴트도 처리) */
/* 3. GPU 페이지 테이블에 매핑 추가 */
/* 4. GPU 작업 재개 */

# GPU 컴퓨트 관련 확인 명령

# Render node 확인
ls -la /dev/dri/renderD*

# KFD 디바이스 확인 (AMD)
ls -la /dev/kfd

# GPU 토폴로지 (AMD ROCm)
cat /sys/class/kfd/kfd/topology/nodes/0/properties

# GPU 메모리 사용량 (amdgpu)
cat /sys/class/drm/card0/device/mem_info_vram_used
cat /sys/class/drm/card0/device/mem_info_gtt_used

# clinfo (OpenCL 디바이스 정보)
clinfo

# vulkaninfo (Vulkan 컴퓨트 능력)
vulkaninfo --summary

NPU (Neural Processing Unit) 개요

NPU(Neural Processing Unit)는 딥러닝 추론/학습 워크로드에 최적화된 전용 하드웨어 가속기입니다. Linux 커널 6.2부터 DRM Accel(drivers/accel/) 서브시스템이 도입되어, GPU와 분리된 전용 디바이스 노드(/dev/accel/accel0)를 통해 NPU 및 AI 가속기를 관리합니다.

NPU vs GPU vs CPU 연산 특성

NPU 하드웨어 아키텍처 개념

NPU의 핵심은 Systolic Array(맥동 배열)를 기반으로 한 행렬 연산 유닛과 전용 데이터 흐름 제어기입니다. 대부분의 NPU는 다음과 같은 공통 구조를 가집니다.

NPU 데이터 흐름

NPU에서 추론을 수행하는 전체 데이터 흐름은 다음과 같습니다.

1. 모델 컴파일: ONNX/TFLite 모델을 NPU 전용 바이너리(blob)로 오프라인 컴파일. 레이어별 타일링, 양자화, 메모리 할당 계획이 포함됨
2. 버퍼 할당: GEM BO(Buffer Object)를 통해 입력/출력/가중치 버퍼를 커널 드라이버에 할당 요청
3. 커맨드 버퍼 생성: UMD가 DMA 전송, 연산 커맨드 등을 커맨드 버퍼에 기록
4. 잡 제출: ioctl을 통해 커맨드 버퍼를 커널에 제출 → drm_sched가 스케줄링
5. HW 실행: 펌웨어가 레이어 단위로 Compute Cluster에 디스패치, SRAM ↔ DDR DMA 전송 관리
6. 완료 통보: IRQ → dma_fence 시그널 → 유저 공간에 결과 전달

양자화(Quantization)와 데이터 타입

NPU는 전력 효율을 위해 낮은 정밀도의 데이터 타입을 사용합니다. MAC 어레이의 데이터 타입에 따라 연산 처리량(TOPS)이 크게 달라집니다.

DRM Accel 서브시스템

DRM Accel은 Linux 6.2에서 도입된 NPU/AI 가속기 전용 프레임워크입니다. DRM의 인프라를 재사용하면서도 GPU와 별개의 디바이스 노드 네임스페이스를 제공합니다.

디바이스 노드 구조

# GPU 디바이스 노드 (DRM)
/dev/dri/card0          # DRM master (KMS + 렌더)
/dev/dri/renderD128     # render-only (non-root GPU 접근)

# NPU/Accel 디바이스 노드 (DRM Accel)
/dev/accel/accel0       # AI 가속기 전용 노드
/dev/accel/accel1       # 두 번째 가속기 (있는 경우)

# sysfs 계층
/sys/class/accel/accel0/
    ├── device           # → PCI/platform 디바이스 심링크
    ├── dev              # major:minor 번호
    └── power/           # 전원 관리 속성

Accel 드라이버 등록

Accel 드라이버는 drm_dev_alloc() 대신 accel_minor_alloc()을 내부적으로 사용합니다. 드라이버는 drm_driver에 DRIVER_COMPUTE_ACCEL 플래그를 설정하여 Accel 모드를 활성화합니다.

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

/* Accel 드라이버 플래그: DRIVER_COMPUTE_ACCEL을 설정하면
 * /dev/accel/accelN 노드가 생성됨 (GPU용 /dev/dri/* 대신)
 * 참고: DRIVER_RENDER와 동시에 사용 불가 */
static const struct drm_driver my_npu_driver = {
    .driver_features    = DRIVER_GEM | DRIVER_COMPUTE_ACCEL,
    .name               = "my_npu",
    .desc               = "My NPU Accelerator",
    .date               = "20250101",
    .major              = 1,
    .minor              = 0,

    /* GEM 오퍼레이션 */
    .gem_create_object  = my_npu_gem_create_object,

    /* ioctl 테이블 */
    .ioctls             = my_npu_ioctls,
    .num_ioctls         = ARRAY_SIZE(my_npu_ioctls),

    /* 파일 오퍼레이션 */
    .fops               = &my_npu_fops,
};

/* probe에서 등록 */
static int my_npu_probe(struct pci_dev *pdev,
                        const struct pci_device_id *ent)
{
    struct drm_device *drm;
    struct my_npu_device *ndev;
    int ret;

    ndev = devm_drm_dev_alloc(&pdev->dev, &my_npu_driver,
                              struct my_npu_device, drm);
    if (IS_ERR(ndev))
        return PTR_ERR(ndev);

    drm = &ndev->drm;
    pci_set_drvdata(pdev, ndev);

    /* HW 초기화: MMIO 매핑, IRQ 등록, 펌웨어 로딩 */
    ret = my_npu_hw_init(ndev);
    if (ret)
        return ret;

    /* drm_dev_register()가 내부적으로 accel_minor를 할당
     * → /dev/accel/accelN 생성 */
    ret = drm_dev_register(drm, 0);
    if (ret)
        goto err_hw;

    dev_info(&pdev->dev, "NPU registered as /dev/accel/accel%d\n",
             drm->accel->index);
    return 0;

err_hw:
    my_npu_hw_fini(ndev);
    return ret;
}

GEM Buffer Object 관리

NPU 드라이버는 GEM을 사용해 가중치, 텐서, 커맨드 버퍼 등의 메모리를 관리합니다. 일반적으로 drm_gem_shmem_object 헬퍼를 확장하거나, 독자적인 GEM 오브젝트를 구현합니다.

/* NPU 전용 GEM 버퍼 오브젝트 */
struct my_npu_bo {
    struct drm_gem_shmem_object base;
    u64  npu_addr;             /* NPU 가상 주소 (디바이스 MMU 매핑) */

    enum {
        NPU_BO_INPUT     = 0,   /* 입력 텐서 */
        NPU_BO_OUTPUT    = 1,   /* 출력 텐서 */
        NPU_BO_WEIGHTS   = 2,   /* 모델 가중치 (읽기 전용) */
        NPU_BO_CMDQ      = 3,   /* 커맨드 큐 */
    } usage;

    bool shared;               /* DMA-BUF로 다른 디바이스와 공유 가능 */
};

/* GEM 생성 ioctl 핸들러 */
static int my_npu_gem_create_ioctl(struct drm_device *dev,
                                    void *data,
                                    struct drm_file *file)
{
    struct my_npu_create_bo *args = data;
    struct my_npu_bo *bo;
    int ret;

    args->size = ALIGN(args->size, SZ_4K);

    bo = my_npu_bo_alloc(dev, args->size, args->flags);
    if (IS_ERR(bo))
        return PTR_ERR(bo);

    /* NPU MMU에 매핑 → npu_addr 할당 */
    ret = my_npu_mmu_map(bo);
    if (ret)
        goto err_free;

    ret = drm_gem_handle_create(file, &bo->base.base, &args->handle);
    drm_gem_object_put(&bo->base.base);
    args->npu_addr = bo->npu_addr;
    return ret;

err_free:
    drm_gem_object_put(&bo->base.base);
    return ret;
}

컴퓨트 잡 제출 (Job Submission)

NPU 드라이버는 drm_sched(GPU 스케줄러)를 재사용하여 컴퓨트 잡을 관리합니다.

/* NPU 잡 구조체 — drm_sched_job을 임베드 */
struct my_npu_job {
    struct drm_sched_job  base;
    struct my_npu_bo     *cmd_bo;      /* 커맨드 버퍼 */
    struct my_npu_bo    **bos;         /* 입출력 버퍼 참조 */
    u32                  bo_count;
    struct dma_fence     *done_fence;  /* 완료 fence */
};

/* drm_sched 백엔드 콜백 */
static struct dma_fence *
my_npu_run_job(struct drm_sched_job *sched_job)
{
    struct my_npu_job *job =
        container_of(sched_job, struct my_npu_job, base);
    struct my_npu_device *ndev = job_to_ndev(job);

    /* 1. 커맨드 버퍼의 NPU 가상 주소를 HW 레지스터에 기록 */
    writel(lower_32_bits(job->cmd_bo->npu_addr),
           ndev->mmio + NPU_REG_CMD_ADDR_LO);
    writel(upper_32_bits(job->cmd_bo->npu_addr),
           ndev->mmio + NPU_REG_CMD_ADDR_HI);

    /* 2. 실행 트리거 — 펌웨어가 처리 시작 */
    writel(NPU_CMD_EXECUTE, ndev->mmio + NPU_REG_DOORBELL);

    /* 3. HW fence 반환 — IRQ 핸들러에서 시그널됨 */
    return dma_fence_get(job->done_fence);
}

static enum drm_gpu_sched_stat
my_npu_timedout_job(struct drm_sched_job *sched_job)
{
    struct my_npu_job *job =
        container_of(sched_job, struct my_npu_job, base);

    dev_err(job->dev, "NPU job timeout — resetting engine\n");
    my_npu_engine_reset(job_to_ndev(job));

    return DRM_GPU_SCHED_STAT_NOMINAL;
}

static const struct drm_sched_backend_ops my_npu_sched_ops = {
    .run_job      = my_npu_run_job,
    .timedout_job = my_npu_timedout_job,
};

펌웨어 로딩

대부분의 NPU는 부팅 시 펌웨어를 로딩해야 합니다. 커널의 request_firmware() API를 사용하여 /lib/firmware/에서 NPU 펌웨어 바이너리를 로드합니다.

static int my_npu_load_firmware(struct my_npu_device *ndev)
{
    const struct firmware *fw;
    int ret;

    ret = request_firmware(&fw, "my_npu/fw.bin", ndev->dev);
    if (ret) {
        dev_err(ndev->dev, "firmware load failed: %d\n", ret);
        return ret;
    }

    /* 펌웨어를 NPU의 내부 SRAM 또는 전용 메모리 영역에 복사 */
    memcpy_toio(ndev->fw_region, fw->data, fw->size);

    /* 부트 레지스터 — 펌웨어 실행 시작 */
    writel(NPU_FW_BOOT, ndev->mmio + NPU_REG_FW_CTRL);

    /* 부팅 완료 대기 (mailbox 통신) */
    ret = my_npu_wait_fw_ready(ndev, 5000);
    release_firmware(fw);
    return ret;
}

NPU MMU (디바이스 가상 메모리)

NPU는 자체 MMU(또는 IOMMU 연동)를 통해 디바이스 가상 주소 공간을 관리합니다. 이를 통해 연속적이지 않은 물리 페이지를 NPU에서 연속 주소로 접근할 수 있습니다.

struct my_npu_mmu {
    struct my_npu_device  *ndev;
    dma_addr_t            pgd_dma;    /* L1 페이지 디렉토리 */
    u64                  *pgd_cpu;    /* CPU 매핑 */
    struct drm_mm         va_space;   /* VA 할당 관리 */
    struct mutex          lock;
};

static int my_npu_mmu_map(struct my_npu_bo *bo)
{
    struct my_npu_mmu *mmu = &bo_to_ndev(bo)->mmu;
    struct drm_mm_node *node = &bo->mm_node;
    struct sg_table *sgt;
    int ret;

    mutex_lock(&mmu->lock);

    /* VA 공간에서 영역 할당 */
    ret = drm_mm_insert_node_generic(&mmu->va_space, node,
                                      bo->base.base.size,
                                      SZ_4K, 0, DRM_MM_INSERT_BEST);
    if (ret)
        goto out;

    bo->npu_addr = node->start;

    sgt = drm_gem_shmem_get_pages_sgt(&bo->base);
    if (IS_ERR(sgt)) {
        drm_mm_remove_node(node);
        ret = PTR_ERR(sgt);
        goto out;
    }

    my_npu_mmu_write_ptes(mmu, bo->npu_addr, sgt);
    my_npu_mmu_flush_tlb(mmu);

out:
    mutex_unlock(&mmu->lock);
    return ret;
}

주요 Linux NPU 드라이버

Intel NPU (IVPU) 드라이버 상세

Intel NPU(이전 명칭 VPU)는 Meteor Lake부터 Intel 클라이언트 프로세서에 통합된 AI 추론 가속기입니다. drivers/accel/ivpu/에 위치하며, DRM Accel 프레임워크를 사용하는 대표적인 드라이버입니다.

drivers/accel/ivpu/ 구조:
├── ivpu_drv.c          # 드라이버 진입점, probe/remove
├── ivpu_drv.h          # 디바이스 구조체 정의
├── ivpu_hw.c           # HW 추상화 (IP 버전별 분기)
├── ivpu_ipc.c          # 펌웨어 IPC (mailbox 프로토콜)
├── ivpu_job.c          # 잡 제출/완료 (drm_sched 사용)
├── ivpu_gem.c          # GEM BO 관리 (shmem 기반)
├── ivpu_mmu.c          # 디바이스 MMU (3-level 페이지 테이블)
├── ivpu_mmu_context.c  # MMU 컨텍스트 (프로세스별 주소 공간)
├── ivpu_fw.c           # 펌웨어 로딩/부팅
├── ivpu_pm.c           # 전원 관리 (Runtime PM)
├── ivpu_jsm_msg.c      # JSM (Job Submission Message) 프로토콜
└── ivpu_debugfs.c      # 디버그 인터페이스

Intel NPU ioctl 인터페이스

AMD XDNA (Ryzen AI) 드라이버

AMD Ryzen AI 프로세서(Phoenix, Hawk Point, Strix Point)에 통합된 XDNA NPU입니다. FPGA 기반 AI Engine 타일로 구성되며, 각 타일은 VLIW 프로세서 + 벡터 유닛을 포함합니다.

drivers/accel/amdxdna/ 구조:
├── aie2_ctx.c          # AIE2 (AI Engine 2) 컨텍스트 관리
├── aie2_message.c      # 펌웨어 메시지 (ERT 프로토콜)
├── aie2_pci.c          # PCIe 드라이버 probe/remove
├── aie2_pm.c           # 전원 관리, DPM 클럭 제어
├── aie2_solver.c       # 하드웨어 리소스 할당 (파티션/컬럼)
├── amdxdna_ctx.c       # DRM 컨텍스트 (클라이언트별 상태)
├── amdxdna_gem.c       # GEM BO 관리
├── amdxdna_mailbox.c   # 호스트↔펌웨어 통신
└── amdxdna_sysfs.c     # sysfs 디버그 속성

Intel Gaudi (habanalabs) 드라이버

데이터센터급 AI 학습/추론 가속기인 Intel Gaudi 시리즈를 지원합니다. DRM Accel 프레임워크 도입 이전부터 존재하며, 6.2에서 drivers/accel/로 이동했습니다.

/* habanalabs 드라이버 핵심 구조 (간략화) */
struct hl_device {
    struct drm_device      drm;
    const struct hl_asic_funcs *asic_funcs;  /* ASIC별 함수 포인터 */
    struct hl_cs_counters_atomic  cs_cnt;    /* 커맨드 서브미션 */
    struct hl_vm            vm;              /* 메모리 관리 */
    struct hl_nic          *nic;             /* 멀티 디바이스 통신 */
    struct hwmon_ops       *hwmon;           /* 전원/열 관리 */
};

/* hl_asic_funcs: ASIC 추상화 인터페이스 */
struct hl_asic_funcs {
    int  (*hw_init)(struct hl_device *hdev);
    void (*hw_fini)(struct hl_device *hdev, bool hard);
    int  (*suspend)(struct hl_device *hdev);
    int  (*resume)(struct hl_device *hdev);
    int  (*cb_mmap)(struct hl_device *hdev,
                    struct vm_area_struct *vma);
    void (*ring_doorbell)(struct hl_device *hdev,
                          u32 hw_queue_id, u32 pi);
    /* ... 50+ 함수 포인터 ... */
};

NPU 전원 관리

NPU는 항상 활성 상태일 필요가 없으므로, Runtime PM을 통한 공격적인 전원 관리가 중요합니다. 특히 노트북/모바일 SoC에서는 추론이 없을 때 NPU를 완전히 꺼서 전력을 절약합니다.

static int my_npu_runtime_suspend(struct device *dev)
{
    struct my_npu_device *ndev = dev_get_drvdata(dev);

    my_npu_wait_idle(ndev);               /* 잡 완료 대기 */
    my_npu_mmu_save_state(ndev);           /* MMU 컨텍스트 저장 */
    clk_disable_unprepare(ndev->clk);     /* 클럭 게이팅 */
    my_npu_power_off(ndev);                /* 전원 도메인 OFF */
    return 0;
}

static int my_npu_runtime_resume(struct device *dev)
{
    struct my_npu_device *ndev = dev_get_drvdata(dev);
    int ret;

    my_npu_power_on(ndev);                 /* 전원 ON */
    clk_prepare_enable(ndev->clk);         /* 클럭 활성화 */

    ret = my_npu_load_firmware(ndev);       /* FW 재로딩 */
    if (ret)
        return ret;

    my_npu_mmu_restore_state(ndev);        /* MMU 복원 */
    return 0;
}

static const struct dev_pm_ops my_npu_pm_ops = {
    SET_RUNTIME_PM_OPS(my_npu_runtime_suspend,
                       my_npu_runtime_resume, NULL)
    SET_SYSTEM_SLEEP_PM_OPS(my_npu_system_suspend,
                            my_npu_system_resume)
};

NPU와 DMA-BUF: 디바이스 간 버퍼 공유

DMA-BUF를 통해 NPU, GPU, 카메라(ISP), 비디오 디코더 간에 제로카피 버퍼 공유가 가능합니다. 이는 카메라 → NPU → GPU → 디스플레이 같은 ML 파이프라인에서 필수적입니다.

/* NPU에서 DMA-BUF 익스포트 (exporter 역할) */
static struct dma_buf *
my_npu_gem_prime_export(struct drm_gem_object *obj, int flags)
{
    struct dma_buf_export_info exp_info = {
        .exp_name  = "my_npu",
        .owner     = obj->dev->driver->fops->owner,
        .ops       = &my_npu_dmabuf_ops,
        .size      = obj->size,
        .flags     = flags,
        .priv      = obj,
    };
    return drm_gem_dmabuf_export(obj->dev, &exp_info);
}

/* GPU에서 NPU의 DMA-BUF를 임포트 (importer 역할) */
struct drm_gem_object *
gpu_gem_prime_import(struct drm_device *dev,
                     struct dma_buf *dma_buf)
{
    struct dma_buf_attachment *attach;
    struct sg_table *sgt;

    attach = dma_buf_attach(dma_buf, dev->dev);
    if (IS_ERR(attach))
        return ERR_CAST(attach);

    sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
    if (IS_ERR(sgt)) {
        dma_buf_detach(dma_buf, attach);
        return ERR_CAST(sgt);
    }

    /* sg_table을 GPU 페이지 테이블에 매핑
     * → NPU가 쓴 결과를 GPU가 직접 읽기 가능 */
    return gpu_create_gem_from_sgt(dev, sgt, dma_buf->size);
}

NPU 커널 설정 (Kconfig)

# DRM Accel 기본 지원
CONFIG_DRM=m                       # DRM 코어 (필수)
CONFIG_DRM_ACCEL=y                 # Accel 서브시스템 활성화

# Intel NPU (IVPU)
CONFIG_DRM_ACCEL_IVPU=m            # Intel VPU/NPU 드라이버

# Intel Gaudi (habanalabs)
CONFIG_DRM_ACCEL_HABANALABS=m      # Gaudi/Gaudi2/Gaudi3

# AMD XDNA (Ryzen AI)
CONFIG_DRM_ACCEL_AMDXDNA=m         # AMD XDNA NPU

# Qualcomm Cloud AI
CONFIG_DRM_ACCEL_QAIC=m            # Qualcomm AIC100

# 공통 의존성
CONFIG_DRM_GEM_SHMEM_HELPER=m      # GEM shmem 헬퍼
CONFIG_DRM_SCHED=m                 # GPU/NPU 스케줄러
CONFIG_DMA_SHARED_BUFFER=y         # DMA-BUF (디바이스 간 공유)
CONFIG_FW_LOADER=y                 # 펌웨어 로더 (필수)
CONFIG_IOMMU_API=y                 # IOMMU 지원

NPU 디버깅

sysfs / debugfs 인터페이스

# Accel 디바이스 확인
ls -la /dev/accel/
ls -la /sys/class/accel/

# Intel NPU debugfs
cat /sys/kernel/debug/accel/0/info
cat /sys/kernel/debug/accel/0/fw_version
cat /sys/kernel/debug/accel/0/busy_time_us
cat /sys/kernel/debug/accel/0/freq

# Runtime PM 상태 확인
cat /sys/class/accel/accel0/device/power/runtime_status

# HW 센서 (hwmon)
cat /sys/class/accel/accel0/device/hwmon/*/temp1_input
cat /sys/class/accel/accel0/device/hwmon/*/power1_input

# AMD XDNA sysfs
cat /sys/class/accel/accel0/device/npu_clk_freq
cat /sys/class/accel/accel0/device/npu_power_state

NPU 디버깅 도구

NPU 유저 공간 소프트웨어 스택

NPU 드라이버는 커널에서 HW 접근과 메모리 관리만 담당하고, 실제 ML 모델 컴파일/실행은 유저 공간 스택이 처리합니다.

# 1. 모델 벤치마크
benchmark_app -m model.onnx -d NPU -hint latency

# 2. Python API로 추론
import openvino as ov

core = ov.Core()
model = core.compile_model("model.onnx", "NPU")
result = model.infer_new_request({"input": input_data})

참고 사항