eMMC/MMC 서브시스템 — Embedded MultiMediaCard & Linux MMC Framework

eMMC(embedded MultiMediaCard)는 NAND 플래시와 컨트롤러를 하나의 BGA 패키지에 통합한 임베디드 스토리지 솔루션으로, 스마트폰, 태블릿, IoT 디바이스, 자동차 인포테인먼트 등에 널리 사용됩니다. 이 문서에서는 JEDEC eMMC 스펙의 프로토콜 기초부터 Linux 커널의 MMC 서브시스템(drivers/mmc/) 구조, SDHCI 호스트 컨트롤러 프레임워크, HS200/HS400 버스(Bus) 튜닝, EXT_CSD 레지스터(Register), 하드웨어 파티션(Boot/RPMB/GP), 인라인 암호화(ICE), 디바이스 트리(Device Tree) 바인딩, sysfs 인터페이스, 디버깅(Debugging), 성능 튜닝, UFS와의 비교까지 eMMC/MMC의 모든 것을 심층 분석합니다.

단계별 이해

1. 1단계 — 호스트가 CMD 라인으로 커맨드 전송
   호스트 컨트롤러(SDHCI)는 CMD 라인(1-bit 양방향)을 통해 48비트 커맨드 프레임을 전송합니다. 커맨드 프레임은 시작 비트(0), 전송 비트(1=호스트→카드), 6비트 커맨드 인덱스, 32비트 인자(argument), 7비트 CRC, 끝 비트(1)로 구성됩니다. 예를 들어 CMD17(READ_SINGLE_BLOCK)을 보내면 인자 필드에 읽고자 하는 블록 주소가 들어갑니다.
   커맨드 프레임 구조 (48비트):
   [Start:1][Tx:1][Cmd Index:6][Argument:32][CRC7:7][End:1]
2. 2단계 — eMMC가 응답(Response) 반환
   eMMC는 같은 CMD 라인을 통해 응답을 돌려보냅니다. 응답 타입에 따라 48비트(R1, R3, R6 등) 또는 136비트(R2 — CID/CSD 전체)가 전송됩니다. 응답에는 카드 상태 비트(ready, error 플래그 등)가 포함되어 호스트가 후속 동작을 결정할 수 있습니다.
3. 3단계 — DAT0~7 라인으로 데이터 전송
   데이터 전송이 필요한 커맨드(ADTC 타입)의 경우, 데이터는 DAT0~DAT7의 8비트 병렬 버스를 통해 전송됩니다. eMMC 5.1의 HS400 모드에서는 200MHz DDR로 동작하여 클럭 엣지마다 8비트 × 2(더블 데이터 레이트) = 16비트를 전송, 이론적 최대 400 MB/s를 달성합니다. 각 블록(512바이트) 전송 후 CRC16 체크가 수행됩니다.
4. 4단계 — 블록 레이어와 mmc_block 통합
   Linux 커널에서 사용자 공간(User Space)의 read()/write() 요청은 VFS → 파일시스템(Filesystem) → 블록 레이어(blk-mq)를 거쳐 mmc_blk_mq_issue_rq() 함수에 도달합니다. 이 함수가 mmc_start_request()를 호출하여 실제 MMC 커맨드를 호스트 컨트롤러에 전달합니다. CMDQ(Command Queuing)가 활성화된 경우 최대 32개의 요청을 동시에 큐에 넣을 수 있습니다.
   blk-mq 연결: eMMC는 mmc_init_queue()에서 blk-mq 하드웨어 큐를 1개(hw_queue = 1)로 설정합니다. CMDQ 모드에서는 CQE(Command Queue Engine) 드라이버가 하드웨어 레벨에서 다중 요청을 병렬 처리합니다.
5. 5단계 — 사용자 공간에서 /dev/mmcblk0pN 접근
   사용자는 /dev/mmcblk0p1 같은 블록 디바이스 노드를 통해 일반 블록 디바이스처럼 eMMC에 접근합니다. 파일시스템(ext4, f2fs 등)을 마운트(Mount)하거나, dd/fio로 직접 블록 I/O를 수행할 수 있습니다. 부트 파티션(mmcblk0boot0)은 기본적으로 쓰기 보호(Write Protection)되어 있으며, echo 0 > /sys/block/mmcblk0boot0/force_ro로 해제해야 쓸 수 있습니다.

   # eMMC 디바이스 확인
   lsblk | grep mmcblk
   # 출력 예시:
   # mmcblk0      179:0    0  29.1G  0 disk
   # ├─mmcblk0p1  179:1    0   256M  0 part /boot
   # ├─mmcblk0p2  179:2    0  28.8G  0 part /
   # mmcblk0boot0 179:32   0     4M  1 disk
   # mmcblk0boot1 179:64   0     4M  1 disk
   
   # eMMC 정보 확인
   cat /sys/class/mmc_host/mmc0/mmc0:0001/name
   cat /sys/class/mmc_host/mmc0/mmc0:0001/fwrev
   cat /sys/class/mmc_host/mmc0/mmc0:0001/hwrev

eMMC 프로토콜 기초

eMMC는 JEDEC 표준에 정의된 MMC 프로토콜을 사용합니다. 모든 통신은 호스트가 CMD 라인으로 커맨드를 보내고, 카드가 응답을 반환하는 마스터-슬레이브 구조입니다. 데이터 전송은 DAT 라인을 통해 이루어지며, 호스트가 제공하는 CLK 신호에 동기화됩니다.

커맨드 타입

MMC 커맨드는 응답 유무와 데이터 전송 여부에 따라 4가지로 분류됩니다.

응답 타입

주요 MMC 커맨드

버스 폭 모드

eMMC는 초기화 시 1-bit 모드(DAT0만 사용)로 시작하며, 호스트가 CMD6(SWITCH)를 통해 EXT_CSD[183] BUS_WIDTH 필드를 변경하여 4-bit 또는 8-bit 모드로 전환합니다. DDR 모드에서는 클럭의 상승/하강 엣지 모두에서 데이터를 전송하여 동일 클럭 주파수에서 2배의 대역폭(Bandwidth)을 얻습니다.

하드웨어 아키텍처

eMMC는 하나의 BGA 패키지 안에 NAND 플래시 어레이, 플래시 컨트롤러(FTL/ECC/WL), 호스트 인터페이스 로직을 통합한 관리형(Managed) NAND 솔루션입니다. 호스트 SoC에는 SDHCI 호환 컨트롤러가 내장되어 있으며, eMMC와 직접 연결됩니다.

eMMC 내부 블록 구성

eMMC 디바이스 내부는 크게 4개의 주요 블록으로 구성됩니다:

• NAND Flash Array: MLC/TLC/QLC NAND 셀로 구성된 실제 저장 영역. 다이(Die) 수에 따라 용량이 결정됩니다.
• Flash Controller: FTL(Flash Translation Layer), ECC(Error Correction Code), Wear Leveling, Bad Block Management를 수행하는 내장 컨트롤러입니다.
• Host Interface: MMC 프로토콜을 처리하는 버스 인터페이스 로직. CMD/DAT 라인 구동, CRC 생성/검증을 담당합니다.
• SRAM Buffer: 읽기/쓰기 캐시 및 EXT_CSD/CSD/CID 레지스터를 저장하는 내부 버퍼(Buffer)입니다.

BGA 핀 배치

전압 모드

속도 모드별 클럭 및 대역폭

Linux MMC 서브시스템 구조

Linux 커널의 MMC 서브시스템은 drivers/mmc/ 디렉토리에 위치하며, eMMC, SD 카드, SDIO 디바이스를 통합적으로 관리합니다. 계층적 구조로 설계되어 있어 호스트 컨트롤러 드라이버와 카드 디바이스 드라이버를 분리합니다.

디렉토리 구조

drivers/mmc/
├── core/               # MMC 코어 프레임워크
│   ├── bus.c           # MMC 버스 드라이버 (mmc_bus_type)
│   ├── core.c          # 코어 기능: 커맨드 전송, 클럭/전압 설정
│   ├── host.c          # mmc_host 등록/해제
│   ├── mmc.c           # eMMC 카드 초기화 (CMD1→CMD2→CMD3→CMD7→EXT_CSD)
│   ├── sd.c            # SD 카드 초기화
│   ├── sdio.c          # SDIO 디바이스 초기화
│   ├── block.c         # mmc_blk: 블록 디바이스 레이어 (blk-mq 연동)
│   ├── queue.c         # mmc_queue: 요청 큐 관리
│   ├── mmc_ops.c       # eMMC 전용 명령 (CMD6/CMD8/CMD14/CMD21 등)
│   ├── sd_ops.c        # SD 전용 명령 (ACMD41/ACMD6 등)
│   ├── crypto.c        # 인라인 암호화(ICE) 프레임워크
│   └── regulator.c     # 전압 레귤레이터 관리
├── host/               # 호스트 컨트롤러 드라이버
│   ├── sdhci.c         # SDHCI 공통 프레임워크
│   ├── sdhci-pltfm.c   # SDHCI 플랫폼 헬퍼
│   ├── sdhci-of-arasan.c  # Arasan/Xilinx SDHCI
│   ├── sdhci-tegra.c   # NVIDIA Tegra SDHCI
│   ├── sdhci-esdhc-imx.c # NXP i.MX SDHCI
│   ├── sdhci-msm.c     # Qualcomm MSM SDHCI
│   ├── sdhci-s3c.c     # Samsung Exynos SDHCI
│   ├── dw_mmc.c        # Synopsys DesignWare MMC 호스트
│   ├── mtk-sd.c        # MediaTek SD/eMMC 호스트
│   ├── cqhci.c         # CQE(Command Queue Engine) 프레임워크
│   └── sdhci-cqhci.c   # SDHCI + CQE 통합
└── Kconfig             # 빌드 설정

핵심 구조체

mmc_host_ops 콜백

호스트 등록 흐름

/* 플랫폼 드라이버의 probe 함수 예시 */
static int my_mmc_probe(struct platform_device *pdev)
{
    struct mmc_host *mmc;
    struct my_host *host;

    /* 1. mmc_host 할당 (private 데이터 포함) */
    mmc = mmc_alloc_host(sizeof(struct my_host), &pdev->dev);
    if (!mmc)
        return -ENOMEM;

    host = mmc_priv(mmc);  /* private 데이터 접근 */
    host->mmc = mmc;

    /* 2. 호스트 capability 설정 */
    mmc->ops = &my_mmc_ops;
    mmc->f_min = 400000;          /* 400 kHz (초기화용) */
    mmc->f_max = 200000000;       /* 200 MHz (HS200/HS400) */
    mmc->ocr_avail = MMC_VDD_27_36 | MMC_VDD_165_195;

    /* eMMC 관련 capability 플래그 */
    mmc->caps = MMC_CAP_8_BIT_DATA    /* 8-bit 버스 지원 */
              | MMC_CAP_4_BIT_DATA     /* 4-bit 버스 지원 */
              | MMC_CAP_NONREMOVABLE   /* eMMC: 분리 불가 */
              | MMC_CAP_MMC_HIGHSPEED  /* High Speed 52 MHz */
              | MMC_CAP_CMD23;         /* CMD23 사전 블록 수 설정 */

    mmc->caps2 = MMC_CAP2_HS200_1_8V_SDR  /* HS200 1.8V */
               | MMC_CAP2_HS400_1_8V       /* HS400 1.8V */
               | MMC_CAP2_HS400_ES          /* HS400ES */
               | MMC_CAP2_NO_SD             /* SD 카드 미지원 */
               | MMC_CAP2_NO_SDIO           /* SDIO 미지원 */
               | MMC_CAP2_CQE;              /* CQE 지원 */

    mmc->max_segs = 128;              /* 최대 scatter 세그먼트 수 */
    mmc->max_seg_size = 65536;        /* 세그먼트당 최대 크기 */
    mmc->max_req_size = 524288;       /* 요청당 최대 크기 (512 KB) */
    mmc->max_blk_size = 512;          /* 블록 크기 */
    mmc->max_blk_count = 65535;       /* 최대 블록 수 */

    /* 3. 하드웨어 초기화 (클럭 게이팅, 리셋 등) */
    my_hw_init(host);

    /* 4. mmc_host 등록 → 카드 탐지 시작 */
    return mmc_add_host(mmc);
}

static void my_mmc_remove(struct platform_device *pdev)
{
    struct mmc_host *mmc = platform_get_drvdata(pdev);
    mmc_remove_host(mmc);
    mmc_free_host(mmc);
}

eMMC 카드 탐지 및 초기화

mmc_add_host() 호출 후 커널은 mmc_rescan() 워크를 통해 카드 탐지를 시작합니다. eMMC는 다음 순서로 초기화됩니다:

1. CMD0 — GO_IDLE_STATE: 카드를 Idle 상태로 리셋합니다.
2. CMD1 — SEND_OP_COND (반복): 동작 전압을 협상합니다. OCR의 busy 비트가 설정될 때까지 반복합니다.
3. CMD2 — ALL_SEND_CID: CID(Card Identification) 레지스터를 읽어 제조사, 제품명, 시리얼 번호를 확인합니다.
4. CMD3 — SET_RELATIVE_ADDR: RCA를 0x0001로 설정합니다 (eMMC는 호스트가 지정).
5. CMD9 — SEND_CSD: CSD 레지스터를 읽어 용량, 최대 전송 속도 등을 확인합니다.
6. CMD7 — SELECT_CARD: 카드를 Transfer State로 전환합니다.
7. CMD8 — SEND_EXT_CSD: 512바이트 EXT_CSD 레지스터를 읽어 상세 설정을 확인합니다.
8. CMD6 — SWITCH (반복): 버스 폭(8-bit), 타이밍(HS200/HS400), 파워 클래스 등을 설정합니다.
9. Tuning: HS200 모드에서 CMD21로 튜닝을 수행합니다. HS400 전환 시 HS200 → DDR52 → HS400 순서를 따릅니다.

SDHCI 프레임워크

SDHCI(SD Host Controller Interface)는 SD Association이 정의한 호스트 컨트롤러 레지스터 맵 표준(현재 v4.20)으로, 대부분의 SoC에 내장된 eMMC/SD 호스트 컨트롤러가 이 스펙을 따릅니다. Linux 커널의 sdhci.c는 SDHCI 공통 프레임워크를 제공하여, 플랫폼별 드라이버는 최소한의 코드만으로 호스트 컨트롤러를 등록할 수 있습니다.

sdhci_host 구조체 주요 필드

struct sdhci_host {
    /* 부모: mmc_host */
    struct mmc_host     *mmc;

    /* SDHCI 레지스터 베이스 주소 (MMIO) */
    void __iomem        *ioaddr;

    /* 인터럽트 번호 */
    int                 irq;

    /* SDHCI capability (CAPS 레지스터에서 읽은 값) */
    unsigned int        caps;       /* SDHCI_CAPABILITIES */
    unsigned int        caps1;      /* SDHCI_CAPABILITIES_1 */

    /* 하드웨어 quirks (비표준 동작 보정) */
    unsigned int        quirks;     /* SDHCI_QUIRK_* */
    unsigned int        quirks2;    /* SDHCI_QUIRK2_* */

    /* 타이머/워크 */
    struct timer_list   timer;      /* 커맨드/데이터 타임아웃 */
    struct work_struct  complete_work; /* 완료 처리 워크 */

    /* DMA 관련 */
    dma_addr_t          adma_addr;  /* ADMA2 descriptor 테이블 물리 주소 */
    void                *adma_table; /* ADMA2 descriptor 테이블 가상 주소 */
    unsigned int        adma_table_sz; /* descriptor 테이블 크기 */

    /* 벤더별 operations */
    const struct sdhci_ops *ops;

    /* CQE 연동 */
    struct cqhci_host   *cqe_host;
    ...
};

sdhci_ops 콜백

SDHCI 레지스터 맵 (주요 레지스터)

주요 플랫폼 드라이버

호스트 컨트롤러 드라이버 비교

SDHCI 표준은 공통 레지스터 인터페이스를 정의하지만, 각 SoC 제조사는 자체 PHY, DMA 엔진, 클럭 게이팅, 인라인 암호화 블록 등을 추가합니다. Linux 커널은 이들을 플랫폼별 드라이버로 구현하며, 각 드라이버는 고유한 튜닝 시퀀스와 quirk 세트를 가집니다.

Qualcomm — sdhci-msm

Qualcomm Snapdragon SoC에 탑재된 SD/eMMC 호스트 컨트롤러입니다. HS400 Enhanced Strobe, ICE(Inline Crypto Engine), CQHCI를 모두 지원하며, Android 디바이스에서 가장 널리 사용됩니다.

/* drivers/mmc/host/sdhci-msm.c — Qualcomm HS400 튜닝 핵심 흐름 */
static int sdhci_msm_hs400_dll_calibration(struct sdhci_host *host)
{
    struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
    struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host);

    /* 1단계: CDR을 비활성화하고 DLL 리셋 */
    writel_relaxed(0, host->ioaddr + msm_host->regs->core_dll_config);
    writel_relaxed(DLL_RST_EN, host->ioaddr + msm_host->regs->core_dll_config);

    /* 2단계: DDR_CAL_EN으로 HS400 캘리브레이션 시작 */
    writel_relaxed(DDR_CAL_EN | DLL_EN,
                   host->ioaddr + msm_host->regs->core_dll_config_2);

    /* 3단계: DLL 잠금 완료 대기 */
    return msm_dll_lock_status(host);
}

/* ICE(Inline Crypto Engine) 키 프로그래밍 */
static int sdhci_msm_program_key(struct cqhci_host *cq_host,
                                  const union cqhci_crypto_cfg_entry *cfg,
                                  int slot)
{
    /* ICE 레지스터에 AES-256-XTS 키를 직접 프로그래밍 */
    qcom_ice_program_key(msm_host->ice, cfg->crypto_cap_idx,
                          QCOM_ICE_CRYPTO_ALG_AES_XTS,
                          cfg->crypto_key, cfg->data_unit_size, slot);
    return 0;
}

Synopsys DesignWare — dw_mmc

Synopsys DesignWare Mobile Storage Host Controller IP는 다수의 SoC 제조사(Samsung Exynos, Rockchip, Allwinner, HiSilicon 등)가 라이선스하여 사용하는 공통 IP 블록입니다. 커널에서 drivers/mmc/host/dw_mmc.c가 코어 드라이버이며, SoC별 글루 드라이버(dw_mmc-exynos.c, dw_mmc-rockchip.c 등)가 PHY 튜닝과 클럭 관리를 담당합니다.

/* drivers/mmc/host/dw_mmc.c — IDMAC Descriptor 설정 */
struct idmac_desc {
    __le32 des0;    /* Control: OWN, CH, DIC, LD, FS 비트 */
    __le32 des1;    /* Buffer Size (최대 4KB per descriptor) */
    __le32 des2;    /* Buffer Address (물리 주소) */
    __le32 des3;    /* Next Descriptor Address (링 버퍼 또는 체인) */
};

/* Exynos 글루 드라이버: Phase Shift 튜닝 */
static int dw_mci_exynos_execute_tuning(struct dw_mci_slot *slot,
                                         u32 opcode)
{
    struct dw_mci *host = slot->host;
    struct dw_mci_exynos_priv_data *priv = host->priv;

    /* 0°부터 360°까지 Phase를 스캔하며 CMD21 전송 */
    for (phase = 0; phase < TUNING_PHASE_MAX; phase++) {
        dw_mci_exynos_set_sample_phase(host, phase);
        if (mmc_send_tuning(mmc, opcode, NULL) == 0)
            pass_window |= (1 << phase);  /* 성공한 Phase 기록 */
    }
    /* 가장 넓은 연속 통과 윈도우의 중심을 최적 Phase로 선택 */
    best_phase = find_best_window_center(pass_window);
    dw_mci_exynos_set_sample_phase(host, best_phase);
    return 0;
}

MediaTek — mtk-sd (MSDC)

MediaTek SoC는 SDHCI 표준을 따르지 않는 독자적인 MSDC(MT SD/MMC Controller)를 사용합니다. 자체 레지스터 맵, 자체 튜닝 알고리즘, DVFS(Dynamic Voltage and Frequency Scaling) 연동이 특징이며, Android 스마트폰과 Chromebook에서 많이 사용됩니다.

/* drivers/mmc/host/mtk-sd.c — PAD 딜레이 튜닝 핵심 */
static int msdc_tune_together(struct mmc_host *mmc, u32 opcode)
{
    struct msdc_host *host = mmc_priv(mmc);
    u32 rise_delay = 0, fall_delay = 0;

    /* 상승 에지(Rising Edge) 딜레이 스캔 */
    sdr_set_bits(host->base + MSDC_IOCON, MSDC_IOCON_RSPL);
    for (i = 0; i < PAD_DELAY_MAX; i++) {
        msdc_set_data_delay(host, i);
        if (mmc_send_tuning(mmc, opcode, NULL) == 0)
            rise_delay |= (1 << i);
    }
    /* 하강 에지(Falling Edge) 딜레이 스캔 */
    sdr_clr_bits(host->base + MSDC_IOCON, MSDC_IOCON_RSPL);
    for (i = 0; i < PAD_DELAY_MAX; i++) {
        msdc_set_data_delay(host, i);
        if (mmc_send_tuning(mmc, opcode, NULL) == 0)
            fall_delay |= (1 << i);
    }
    /* 상승/하강 중 더 넓은 통과 윈도우를 가진 에지를 선택 */
    final_delay = get_best_delay(host, rise_delay, fall_delay);
    msdc_set_data_delay(host, final_delay);
    return 0;
}

NXP i.MX — sdhci-esdhc-imx

NXP(구 Freescale) i.MX 시리즈에 탑재된 uSDHC(Ultra Secured Digital Host Controller)입니다. SDHCI 호환이지만 레지스터 오프셋과 비트 배치가 표준과 다르며, 자체 Strobe DLL과 Auto-Tuning 회로를 갖추고 있습니다. 산업용/자동차 등급 i.MX8/i.MX9에서 eMMC 5.1을 주로 사용합니다.

Renesas — renesas_sdhi / tmio

Renesas R-Car 시리즈(자동차 SoC)의 SDHI 컨트롤러는 TMIO(Toshiba Mobile I/O) IP를 기반으로 합니다. SCC(Sampling Clock Controller)로 TAP(Timing Adjustment Point) 딜레이를 조정하며, 차량용 eMMC의 넓은 온도 범위(-40°C ~ +125°C)에서 안정적인 동작을 보장합니다.

Intel — sdhci-pci

Intel Bay Trail, Apollo Lake, Elkhart Lake 등의 플랫폼에 내장된 eMMC 호스트 컨트롤러입니다. PCI 디바이스로 열거되며 ACPI를 통해 설정됩니다. 주로 IoT 게이트웨이, 산업용 PC, 일부 Chromebook에서 사용됩니다.

Allwinner — sunxi-mmc

Allwinner A-시리즈/H-시리즈(A64, H6, H616 등) SoC의 독자 MMC 컨트롤러입니다. 저가형 SBC(Single Board Computer)와 미디어 플레이어에서 주로 사용되며, 자동 튜닝 회로가 없어 수동 Phase 캘리브레이션이 필요합니다.

Broadcom — sdhci-bcm2835 / sdhci-iproc

Raspberry Pi(BCM2835/BCM2711)에 사용되는 Broadcom의 eMMC/SD 호스트 컨트롤러입니다. BCM2711(RPi 4)은 EMMC2 컨트롤러를 통해 HS200까지 지원하지만, BCM2835(RPi 1~3)는 Arasan SDHCI IP의 비표준 구현으로 다양한 quirk를 필요로 합니다.

호스트 컨트롤러 드라이버 종합 비교

요청 처리 파이프라인(Pipeline)

사용자 공간의 I/O 요청이 eMMC 하드웨어까지 도달하는 전체 경로를 추적합니다. 일반(non-CQE) 경로와 CMDQ(CQE) 경로를 모두 살펴봅니다.

일반 요청 흐름

CQE가 비활성화된 상태에서의 요청 경로입니다:

1. submit_bio() → blk-mq 소프트웨어 큐에 bio 삽입
2. blk-mq 스케줄러(Scheduler)가 request를 디스패치(Dispatch) → mmc_blk_mq_issue_rq() 호출
3. mmc_blk_mq_issue_rw_rq()에서 mmc_start_request() → host->ops->request()
4. SDHCI: sdhci_request() → 레지스터에 CMD/ARG/블록 정보 기록 → 커맨드 발행
5. 하드웨어가 CMD 전송 → 응답 수신 → DMA로 데이터 전송
6. 인터럽트 발생 → sdhci_irq() → mmc_request_done()
7. mmc_blk_mq_complete_rq() → blk-mq 완료 처리

CQE/CMDQ 경로

eMMC 5.1의 CMDQ(Command Queuing)는 호스트와 eMMC 사이에 최대 32개의 태스크(Task)를 동시에 큐에 넣을 수 있는 기능입니다. 커널의 CQE 프레임워크(cqhci.c)는 JEDEC의 CQHCI(Command Queue Host Controller Interface) 스펙을 구현합니다.

DMA 모드

SDHCI는 3가지 DMA 모드를 지원합니다. 현대 드라이버는 대부분 ADMA2를 사용합니다.

ADMA2 Descriptor 구조

/* ADMA2 descriptor (64-bit 엔트리) */
struct sdhci_adma2_64_desc {
    __le16 cmd;     /* 속성: Valid, End, Int, Act(Tran/Link/Nop) */
    __le16 len;     /* 전송 길이 (0 = 65536) */
    __le32 addr_lo; /* 시스템 메모리 주소 (하위 32-bit) */
    __le32 addr_hi; /* 시스템 메모리 주소 (상위 32-bit, v4 모드) */
};

/* ADMA2 속성 비트 */
#define SDHCI_ADMA2_DESC_VALID  (1 << 0)  /* 이 descriptor가 유효함 */
#define SDHCI_ADMA2_DESC_END    (1 << 1)  /* 마지막 descriptor */
#define SDHCI_ADMA2_DESC_INT    (1 << 2)  /* 이 descriptor 완료 시 인터럽트 */
#define SDHCI_ADMA2_DESC_ACT_TRAN (2 << 4) /* 데이터 전송 */
#define SDHCI_ADMA2_DESC_ACT_LINK (3 << 4) /* 다음 descriptor 테이블 링크 */
#define SDHCI_ADMA2_DESC_ACT_NOP  (0 << 4) /* No-operation */

블록 디바이스 핵심 구조체

요청 처리 코드 흐름

/* core/block.c — blk-mq 요청 진입점 */
static blk_status_t mmc_blk_mq_issue_rq(struct mmc_queue *mq,
                                         struct request *req)
{
    struct mmc_blk_data *md = mq->blkdata;
    struct mmc_card *card = md->queue.card;

    switch (mmc_issue_type(mq, req)) {
    case MMC_ISSUE_SYNC:
        /* 특수 요청 (DISCARD, FLUSH 등) */
        return mmc_blk_mq_issue_rw_rq(mq, req);

    case MMC_ISSUE_DCMD:
        /* CQE Direct Command (비데이터 커맨드) */
        return mmc_blk_cqe_issue_rw_rq(mq, req);

    case MMC_ISSUE_ASYNC:
        /* CQE 비동기 데이터 요청 */
        return mmc_blk_cqe_issue_rw_rq(mq, req);

    default:
        /* 일반 읽기/쓰기 */
        return mmc_blk_mq_issue_rw_rq(mq, req);
    }
}

/* 일반 읽기/쓰기 요청 → MMC 커맨드 변환 */
static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq,
                                struct mmc_card *card,
                                int disable_multi,
                                struct mmc_queue *mq)
{
    struct mmc_blk_request *brq = &mqrq->brq;
    struct request *req = mmc_queue_req_to_req(mqrq);

    brq->cmd.arg = blk_rq_pos(req);  /* 블록 주소 */
    if (!mmc_card_blockaddr(card))
        brq->cmd.arg <<= 9;          /* 바이트 주소 변환 */

    brq->data.blksz = 512;
    brq->data.blocks = blk_rq_sectors(req);

    if (rq_data_dir(req) == READ) {
        brq->cmd.opcode = brq->data.blocks > 1
            ? MMC_READ_MULTIPLE_BLOCK   /* CMD18 */
            : MMC_READ_SINGLE_BLOCK;    /* CMD17 */
        brq->data.flags = MMC_DATA_READ;
    } else {
        brq->cmd.opcode = brq->data.blocks > 1
            ? MMC_WRITE_MULTIPLE_BLOCK  /* CMD25 */
            : MMC_WRITE_BLOCK;          /* CMD24 */
        brq->data.flags = MMC_DATA_WRITE;
    }

    /* CMD23 (SET_BLOCK_COUNT) 사전 설정 */
    if (brq->data.blocks > 1 && mmc_card_cmd23(card)) {
        brq->sbc.opcode = MMC_SET_BLOCK_COUNT; /* CMD23 */
        brq->sbc.arg = brq->data.blocks;
        brq->mrq.sbc = &brq->sbc;
    }
}

CQHCI 심화 — Command Queue Host Controller Interface

CQHCI(Command Queue Host Controller Interface)는 JEDEC에서 정의한 eMMC 커맨드 큐잉의 호스트 측 표준입니다. eMMC 5.1의 CMDQ(CMD44/CMD45/CMD46/CMD47) 프로토콜을 하드웨어 레벨에서 가속하여, 최대 32개의 태스크를 동시에 관리하고 호스트 CPU 개입 없이 자동으로 디스패치합니다. 커널에서는 drivers/mmc/host/cqhci.c가 공통 구현을 제공하며, Qualcomm, MediaTek, Intel, NXP 등의 호스트 드라이버가 이를 사용합니다.

CQHCI 아키텍처

CQHCI는 호스트 메모리에 위치한 Task Descriptor List와 Transfer Descriptor List를 통해 eMMC와 통신합니다. 소프트웨어는 Task Descriptor에 커맨드 정보를 기록하고 Doorbell 레지스터를 쓰면, 하드웨어가 자동으로 CMD44/CMD45(Task Descriptor 전송) → CMD46/CMD47(데이터 전송)을 수행합니다.

CQHCI 주요 레지스터

커널 CQHCI 구현

/* drivers/mmc/host/cqhci.c — 핵심 함수 흐름 */

/* 1. CQHCI 초기화: 호스트 드라이버가 probe 시 호출 */
int cqhci_init(struct cqhci_host *cq_host, struct mmc_host *mmc,
               bool dma64)
{
    /* Task Descriptor List 할당 (32 슬롯 × 128-bit each) */
    cq_host->desc_size = dma64 ? 16 : 8;  /* 64-bit: 16B, 32-bit: 8B */
    cq_host->data_size = dma64 ? 16 : 8;  /* Transfer Desc도 동일 */

    /* DMA 일관성 메모리에 Descriptor 목록 할당 */
    cq_host->trans_desc_base = dmam_alloc_coherent(
        mmc_dev(mmc), cq_host->trans_desc_len,
        &cq_host->trans_desc_dma_base, GFP_KERNEL);

    /* CQCFG: CQE 활성화, 128-bit Task Descriptor 모드 */
    cqhci_writel(cq_host, CQHCI_TASK_DESC_SZ_128 | CQHCI_ENABLE,
                 CQHCI_CFG);

    /* CQTDLBA: Descriptor 기본 주소 설정 */
    cqhci_writel(cq_host, lower_32_bits(cq_host->desc_dma_base),
                 CQHCI_TDLBA);
    cqhci_writel(cq_host, upper_32_bits(cq_host->desc_dma_base),
                 CQHCI_TDLBAU);
    return 0;
}

/* 2. 요청 제출: blk-mq에서 새 I/O 요청이 도착하면 호출 */
static blk_status_t cqhci_request(struct mmc_host *mmc,
                                   struct mmc_request *mrq)
{
    struct cqhci_host *cq_host = mmc->cqe_private;
    int tag = mrq->tag;  /* blk-mq 태그 = CQHCI 슬롯 번호 */

    /* Task Descriptor 작성: 방향, LBA, 블록 수, 우선순위 */
    cqhci_prep_task_desc(mrq, &cq_host->slot[tag].task_desc);

    /* Transfer Descriptor(Scatter-Gather List) 작성 */
    cqhci_prep_tran_desc(mrq, cq_host, tag);

    /* Doorbell 레지스터에 해당 슬롯 비트를 SET → HW가 자동 디스패치 */
    cqhci_writel(cq_host, 1 << tag, CQHCI_TDBR);
    return BLK_STS_OK;
}

/* 3. 완료 인터럽트 핸들러 */
irqreturn_t cqhci_irq(struct mmc_host *mmc, u32 intmask,
                      int cmd_error, int data_error)
{
    struct cqhci_host *cq_host = mmc->cqe_private;

    /* CQIS(Interrupt Status) 읽기 */
    status = cqhci_readl(cq_host, CQHCI_IS);

    if (status & CQHCI_IS_TCC) {
        /* Task Complete: CQTCN에서 완료 비트맵 읽기 */
        comp_status = cqhci_readl(cq_host, CQHCI_TCN);
        cqhci_writel(cq_host, comp_status, CQHCI_TCN); /* W1C */

        for_each_set_bit(tag, &comp_status, 32) {
            mrq = cq_host->slot[tag].mrq;
            mmc_cqe_request_done(mmc, mrq);  /* blk-mq 완료 콜백 */
        }
    }

    if (status & CQHCI_IS_RED) {
        /* Response Error: 에러 복구 — CQE Halt → 재발행 */
        cqhci_error_handler(mmc);
    }
    return IRQ_HANDLED;
}

인터럽트 병합(Interrupt Coalescing)

매 태스크 완료마다 인터럽트를 발생시키면 CPU 오버헤드가 큽니다. CQHCI는 CQIC 레지스터를 통해 타이머/카운터 기반의 인터럽트 병합을 지원합니다.

/* 인터럽트 병합 설정 예시: 8개 태스크 또는 1ms 중 먼저 도달 시 인터럽트 */
u32 ic_val = CQHCI_IC_ENABLE |
            CQHCI_IC_ICCTHWEN | (8 << CQHCI_IC_ICCTH_SHIFT) |   /* 카운터 = 8 */
            CQHCI_IC_ICTOVALWEN | (0x14 << CQHCI_IC_ICTOVAL_SHIFT); /* 타이머 ≈ 1ms */
cqhci_writel(cq_host, ic_val, CQHCI_IC);

에러 복구 절차

CQHCI에서 에러가 발생하면(CRC 에러, 타임아웃 등) 다음 절차로 복구합니다. 이 과정은 cqhci.c의 cqhci_recovery_start()와 cqhci_recovery_finish()에 구현되어 있습니다.

1. CQE Halt — CQCTL에 Halt 비트를 설정하여 새 태스크 디스패치를 중지합니다.
2. 에러 태스크 식별 — CQTERRI 레지스터에서 에러가 발생한 태스크 번호와 CMD 인덱스를 확인합니다.
3. 태스크 클리어 — CQTCLR로 해당 슬롯을 클리어하거나, 심각한 에러 시 CQCTL의 Clear All Tasks로 전체 초기화합니다.
4. SDHCI 리셋 — 호스트 컨트롤러의 CMD/DAT 라인을 소프트 리셋합니다.
5. CQE 재시작 — Halt를 해제하고, 실패한 태스크와 미완료 태스크를 blk-mq에 재큐잉합니다.

CQHCI 인라인 암호화 (Crypto Extension)

CQHCI Crypto Extension은 128-bit Task Descriptor의 상위 64비트에 암호화 설정을 포함합니다. 각 태스크마다 독립적인 암호화 키 슬롯과 DUN(Data Unit Number)을 지정할 수 있어, 파일 단위 암호화(fscrypt)와 자연스럽게 통합됩니다.

버스 모드 튜닝

eMMC는 세대가 발전하면서 버스 인터페이스 속도가 비약적으로 향상되었습니다. 호스트 컨트롤러는 카드의 CARD_TYPE(EXT_CSD[196]) 필드를 읽어 지원 가능한 최고 속도 모드를 협상하고, 해당 모드에 맞는 타이밍 튜닝을 수행합니다.

CMD21 튜닝 절차 (HS200)

HS200 모드에서는 200 MHz의 높은 클럭 주파수로 인해 데이터 샘플링 포인트를 정확히 조정해야 합니다. 호스트 컨트롤러는 CMD21 (SEND_TUNING_BLOCK)을 사용하여 튜닝 블록을 읽고, 수신된 데이터 패턴을 기대값과 비교하여 최적의 샘플링 위상(phase)을 결정합니다.

1. 호스트가 CMD21을 전송하면 카드는 미리 정의된 튜닝 데이터 패턴(4-bit: 64바이트, 8-bit: 128바이트)을 응답합니다.
2. 호스트 컨트롤러가 내부 딜레이 라인의 위상을 0°부터 360° 범위로 순차적으로 변경하면서 CMD21을 반복 전송합니다.
3. 각 위상에서 수신 데이터를 기대 패턴과 비교하여 성공/실패를 기록합니다.
4. 연속 성공 구간(pass window)의 중앙점을 최적 샘플링 포인트로 선택합니다.
5. 선택된 위상을 호스트 컨트롤러에 설정하여 이후 모든 데이터 전송에 사용합니다.

/* drivers/mmc/host/sdhci.c — 튜닝 구현 핵심 */
static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode)
{
    struct sdhci_host *host = mmc_priv(mmc);
    int tuning_count = 0;
    bool hs400_tuning;

    hs400_tuning = host->flags & SDHCI_HS400_TUNING;

    if (host->tuning_mode == SDHCI_TUNING_MODE_1)
        tuning_count = host->tuning_count;

    /*
     * HS200 → CMD21 (SEND_TUNING_BLOCK_HS200)
     * SD UHS-I → CMD19 (SEND_TUNING_BLOCK)
     */
    sdhci_writew(host, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE);

    /* Execute HW Auto Tuning 또는 SW 루프 */
    sdhci_start_tuning(host);

    host->tuning_err = __sdhci_execute_tuning(host, opcode);

    sdhci_end_tuning(host);

    /* HS400 전환 시: HS200 튜닝 후 HS400으로 모드 전환 */
    if (hs400_tuning)
        return host->ops->hs400_downgrade(host);

    /* 재튜닝 타이머 설정 (온도/전압 변화 대응) */
    if (!host->tuning_err && tuning_count)
        mod_timer(&host->tuning_timer,
                  jiffies + tuning_count * HZ);

    return host->tuning_err;
}

HS400 Enhanced Strobe (DS 핀)

HS400 모드에서는 DDR(Double Data Rate)로 동작하므로 CLK의 상승/하강 에지 모두에서 데이터를 샘플링합니다. 그러나 200 MHz DDR에서 정확한 타이밍 마진 확보가 어렵기 때문에, eMMC 5.1에서는 Enhanced Strobe (HS400ES)를 도입했습니다.

HS400ES에서는 카드가 DS(Data Strobe) 핀을 통해 데이터와 동기화된 스트로브 신호를 출력합니다. 호스트는 CLK 기반 샘플링 대신 이 DS 신호의 에지에서 데이터를 캡처하므로, CMD21 기반 튜닝이 불필요합니다. 이는 부팅 시간 단축과 안정성 향상에 크게 기여합니다.

커널 튜닝 API

/* include/linux/mmc/host.h — 튜닝 관련 API */

/* 호스트 드라이버가 구현하는 ops */
struct mmc_host_ops {
    /* 튜닝 실행: opcode = CMD19(SD) 또는 CMD21(eMMC) */
    int (*execute_tuning)(struct mmc_host *host, u32 opcode);
    /* 튜닝 준비/해제 */
    int (*prepare_hs400_tuning)(struct mmc_host *host,
                                struct mmc_ios *ios);
    /* HS400 Enhanced Strobe 설정 */
    void (*hs400_enhanced_strobe)(struct mmc_host *host,
                                  struct mmc_ios *ios);
};

/* core 레이어 튜닝 함수 */
int mmc_execute_tuning(struct mmc_host *host);  /* 튜닝 실행 */
void mmc_retune_enable(struct mmc_host *host);  /* 재튜닝 활성화 */
void mmc_retune_disable(struct mmc_host *host); /* 재튜닝 비활성화 */
int mmc_retune(struct mmc_host *host);          /* 재튜닝 실행 */
void mmc_retune_hold(struct mmc_host *host);    /* 재튜닝 일시 중지 */
void mmc_retune_release(struct mmc_host *host); /* 재튜닝 재개 */

/* 재튜닝 타이머: 온도/전압 변동 시 주기적 재튜닝 */
void mmc_retune_timer_stop(struct mmc_host *host);
void mmc_retune_needed(struct mmc_host *host);  /* 즉시 재튜닝 요청 */

제조사별 Quirk 및 호환성

eMMC 표준은 JEDEC에서 정의하지만, 각 제조사의 펌웨어(Firmware) 구현에는 미묘한 차이와 버그가 존재합니다. Linux 커널은 CID(Card Identification) 레지스터의 manfid(제조사 ID)와 name 필드를 읽어 특정 제조사/모델에 대한 quirk(보정 플래그)를 적용합니다. 이 메커니즘은 drivers/mmc/core/quirks.h와 drivers/mmc/core/card.h에 정의되어 있습니다.

CID 기반 제조사 판별

eMMC의 CID 레지스터(128비트)에서 제조사를 판별하는 핵심 필드는 다음과 같습니다.

# CID 정보 확인 (sysfs 경로)
cat /sys/class/mmc_host/mmc0/mmc0:0001/cid
# 출력 예: 150100514e423136100264f1c700e801
#          ──── ──── ──────── ── ──────── ────
#          MID  OID  PNM      PRV PSN      MDT

# 개별 필드 확인
cat /sys/class/mmc_host/mmc0/mmc0:0001/manfid   # 0x000015 (Samsung)
cat /sys/class/mmc_host/mmc0/mmc0:0001/name      # QNB16
cat /sys/class/mmc_host/mmc0/mmc0:0001/fwrev     # 0x10
cat /sys/class/mmc_host/mmc0/mmc0:0001/hwrev     # 0x0
cat /sys/class/mmc_host/mmc0/mmc0:0001/oemid     # 0x0100

주요 제조사 ID(MID) 목록

Samsung Quirk

Samsung은 eMMC 시장 점유율이 가장 높으며, Linux 커널에서도 가장 많은 quirk가 등록되어 있습니다.

/* drivers/mmc/core/quirks.h — Samsung eMMC quirk 등록 예시 */
MMC_FIXUP("VYL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY,
          add_quirk_mmc, MMC_QUIRK_TRIM_BROKEN),
MMC_FIXUP("KYL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY,
          add_quirk_mmc, MMC_QUIRK_TRIM_BROKEN),

/* CID의 name 필드("VYL00M")와 manfid(0x15)가 일치하면
   MMC_QUIRK_TRIM_BROKEN 플래그를 설정하여 TRIM 커맨드를 비활성화 */

/* 커널 내부: quirk 적용 로직 */
static void mmc_fixup_device(struct mmc_card *card,
                             const struct mmc_fixup *table)
{
    for (f = table; f->vendor_fixup; f++) {
        if ((f->manfid == CID_MANFID_ANY ||
             f->manfid == card->cid.manfid) &&
            (f->oemid == CID_OEMID_ANY ||
             f->oemid == card->cid.oemid) &&
            (!f->name[0] ||
             !strncmp(f->name, card->cid.prod_name, sizeof(f->name))))
            f->vendor_fixup(card, f->data);
    }
}

Micron Quirk

SK Hynix Quirk

SanDisk/Western Digital Quirk

Toshiba/Kioxia Quirk

커널 Quirk 전체 플래그 정리

/* drivers/mmc/core/quirks.h — 주요 제조사별 fixup 테이블 (발췌) */

/* Samsung: 여러 모델에서 TRIM 깨짐 */
MMC_FIXUP("VYL00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY,
          add_quirk_mmc, MMC_QUIRK_TRIM_BROKEN),
MMC_FIXUP("VTU00M", CID_MANFID_SAMSUNG, CID_OEMID_ANY,
          add_quirk_mmc, MMC_QUIRK_TRIM_BROKEN),

/* Micron: 특정 리비전 이하에서 TRIM 깨짐 */
MMC_FIXUP(CID_NAME_ANY, CID_MANFID_MICRON, 0x0200,
          add_quirk_mmc_rev, MMC_QUIRK_TRIM_BROKEN, 0, 0x25),

/* SK Hynix: HPI 깨짐 */
MMC_FIXUP(CID_NAME_ANY, CID_MANFID_HYNIX, CID_OEMID_ANY,
          add_quirk_mmc, MMC_QUIRK_BROKEN_HPI),

/* Kingston: Cache Flush 이슈 */
MMC_FIXUP("V10016", CID_MANFID_KINGSTON, CID_OEMID_ANY,
          add_quirk_mmc, MMC_QUIRK_BROKEN_CACHE_FLUSH),

/* SanDisk iNAND: 특수 CMD38 처리 */
MMC_FIXUP(CID_NAME_ANY, CID_MANFID_SANDISK, CID_OEMID_ANY,
          add_quirk_mmc, MMC_FIXUP_INAND_CMD38),

벤더 전용 커맨드(Vendor Command)

JEDEC 표준은 CMD56(GEN_CMD)과 CMD62를 벤더 전용 용도로 예약합니다. 각 제조사는 이 커맨드를 통해 표준에 없는 진단, 모니터링, 테스트 기능을 제공합니다.

/* SanDisk iNAND Health Report 읽기 예시 (커널 모듈 또는 유저스페이스 ioctl) */
struct mmc_command cmd = {
    .opcode  = MMC_GEN_CMD,       /* CMD56 */
    .arg     = 0x110005F9,        /* SanDisk Health Report arg */
    .flags   = MMC_RSP_R1 | MMC_CMD_ADTC,
};
struct mmc_data data = {
    .blksz   = 512,
    .blocks  = 1,
    .flags   = MMC_DATA_READ,
    .sg      = &sg,
    .sg_len  = 1,
};
u8 health_buf[512];
sg_init_one(&sg, health_buf, 512);

mmc_claim_host(card->host);
mmc_wait_for_req(card->host, &mrq);
mmc_release_host(card->host);

/* health_buf 파싱 예시 (SanDisk iNAND 포맷) */
u32 initial_bad   = health_buf[8]  | (health_buf[9]  << 8);   /* 초기 배드블록 */
u32 runtime_bad   = health_buf[10] | (health_buf[11] << 8);   /* 런타임 배드블록 */
u32 pe_count      = health_buf[12] | (health_buf[13] << 8)
                   | (health_buf[14] << 16);                      /* 최대 P/E 카운트 */
u32 power_cycles  = health_buf[16] | (health_buf[17] << 8)
                   | (health_buf[18] << 16);                      /* 전원 사이클 횟수 */

SDHCI 호스트 Quirk 주요 플래그

디바이스(eMMC 카드) 측 quirk 외에, 호스트 컨트롤러 측에도 SDHCI_QUIRK_* 플래그가 있습니다. 이들은 SoC별 SDHCI 구현의 비표준 동작을 보정합니다.

EXT_CSD 레지스터

EXT_CSD(Extended CSD)는 eMMC 카드의 확장 설정 레지스터로, 총 512바이트 크기입니다. 기존 CSD 레지스터(128비트)로는 표현할 수 없는 eMMC 고유 기능들의 설정과 상태 정보를 담고 있으며, CMD8 (SEND_EXT_CSD)을 통해 읽을 수 있습니다.

레지스터 구조

EXT_CSD는 두 영역으로 나뉩니다:

• Properties 영역 (바이트 192~511): 읽기 전용(Read-Only). 카드의 하드웨어 능력 및 스펙 정보를 제공합니다.
• Modes 영역 (바이트 0~191): 읽기/쓰기 가능. 카드의 동작 모드를 설정합니다. CMD6 (SWITCH)로 변경합니다.

mmc-utils로 EXT_CSD 읽기

# 전체 EXT_CSD 덤프
sudo mmc extcsd read /dev/mmcblk0

# 특정 필드 확인 (사람이 읽기 편한 형태)
sudo mmc extcsd read /dev/mmcblk0 | grep -i "card type"
sudo mmc extcsd read /dev/mmcblk0 | grep -i "life time"

# EXT_CSD 원시 데이터를 파일로 덤프
sudo mmc extcsd dump /dev/mmcblk0 > extcsd_dump.bin

# 수명 정보 확인 (eMMC 건강 상태)
sudo mmc extcsd read /dev/mmcblk0 | grep -E "EOL|LIFE_TIME"

# 펌웨어 버전 확인
sudo mmc extcsd read /dev/mmcblk0 | grep -i firmware

커널에서 EXT_CSD 접근

/* drivers/mmc/core/mmc_ops.c — EXT_CSD 읽기 */
int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
{
    int err;
    u8 *ext_csd;

    if (!card || !new_ext_csd)
        return -EINVAL;

    if (!mmc_can_ext_csd(card))
        return -EOPNOTSUPP;

    ext_csd = kzalloc(512, GFP_KERNEL);
    if (!ext_csd)
        return -ENOMEM;

    /* CMD8 (SEND_EXT_CSD) 전송 */
    err = mmc_send_ext_csd(card, ext_csd);
    if (err) {
        kfree(ext_csd);
        return err;
    }

    *new_ext_csd = ext_csd;
    return 0;
}

/* EXT_CSD 특정 필드 읽기 예시 */
static void mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd)
{
    /* Properties 영역 (읽기 전용) */
    card->ext_csd.rev = ext_csd[EXT_CSD_REV];                /* [192] */
    card->ext_csd.card_type = ext_csd[EXT_CSD_CARD_TYPE];    /* [196] */
    card->ext_csd.sectors =
        ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
        ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
        ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
        ext_csd[EXT_CSD_SEC_CNT + 3] << 24;                  /* [212-215] */

    /* 수명 정보 */
    card->ext_csd.pre_eol_info = ext_csd[267];
    card->ext_csd.device_life_time_est_typ_a = ext_csd[268];
    card->ext_csd.device_life_time_est_typ_b = ext_csd[269];

    /* Modes 영역 (읽기/쓰기 가능) — CMD6 SWITCH로 변경 */
    card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG]; /* [179] */
    card->ext_csd.cache_size =
        ext_csd[249] | ext_csd[250] << 8 |
        ext_csd[251] << 16 | ext_csd[252] << 24;             /* [249-252] */
    card->ext_csd.cache_ctrl = ext_csd[33];
}

eMMC 파티션 관리

eMMC는 소프트웨어 파티션 테이블(GPT/MBR)과 별개로, 하드웨어 수준의 물리 파티션을 내장하고 있습니다. 각 파티션은 독립적인 주소 공간(Address Space)과 접근 제어(Access Control)를 가지며, Linux 커널은 이를 별도의 블록 디바이스로 노출합니다.

PARTITION_CONFIG 레지스터

EXT_CSD[179] PARTITION_CONFIG 레지스터는 부트 파티션 활성화와 접근 대상 파티션을 제어합니다:

• 비트 [5:3] BOOT_PARTITION_ENABLE: 부팅 시 읽을 파티션 지정 (0=미사용, 1=Boot1, 2=Boot2, 7=UDA)
• 비트 6 BOOT_ACK: 부트 ACK 응답 활성화
• 비트 [2:0] PARTITION_ACCESS: 현재 접근 대상 파티션 (0=UDA, 1=Boot1, 2=Boot2, 3=RPMB, 4=GP1, ...)

# 부트 파티션 설정: Boot Partition 1에서 부팅, ACK 활성화
sudo mmc bootpart enable 1 1 /dev/mmcblk0

# 현재 부트 설정 확인
sudo mmc extcsd read /dev/mmcblk0 | grep "PARTITION_CONFIG"

# 부트 버스 조건 설정 (8-bit, HS 모드)
sudo mmc bootbus set single_backward retain x8 /dev/mmcblk0

RPMB (Replay Protected Memory Block)

RPMB는 인증된 접근만 허용하는 보안 파티션입니다. 일반적인 read/write 대신 인증 프로토콜을 사용하며, 재전송(Retransmission) 공격(replay attack)을 방지합니다.

• 인증 키: 256비트 HMAC-SHA256 키를 1회 프로그래밍 (변경 불가)
• 쓰기 카운터: 매 인증 쓰기마다 단조 증가 (재전송 방지)
• MAC: 모든 접근 프레임에 HMAC-SHA256 MAC 첨부
• 프레임 크기: 512바이트 고정 (256바이트 데이터 + 메타데이터)

# RPMB 키 프로그래밍 (최초 1회, 복구 불가!)
sudo mmc rpmb write-key /dev/mmcblk0rpmb /path/to/key_file

# RPMB 쓰기 카운터 읽기
sudo mmc rpmb read-counter /dev/mmcblk0rpmb

# RPMB 데이터 쓰기 (인증 필요)
sudo mmc rpmb write-block /dev/mmcblk0rpmb 0 /path/to/data /path/to/key

# RPMB 데이터 읽기
sudo mmc rpmb read-block /dev/mmcblk0rpmb 0 1 -

부트 파티션 쓰기

Linux 커널은 부트 파티션을 기본적으로 읽기 전용으로 마운트합니다. 쓰기를 위해서는 force_ro sysfs 파라미터를 해제해야 합니다.

# 부트 파티션 쓰기 보호 해제
echo 0 > /sys/block/mmcblk0boot0/force_ro

# 부트로더 이미지 기록
sudo dd if=u-boot.bin of=/dev/mmcblk0boot0 bs=512 seek=0 conv=fsync

# 쓰기 보호 재활성화
echo 1 > /sys/block/mmcblk0boot0/force_ro

# Boot Partition 1에서 부팅하도록 설정
sudo mmc bootpart enable 1 1 /dev/mmcblk0

Enhanced User Data Area 및 GP 파티션

eMMC 4.4 이상에서는 User Data Area의 일부를 Enhanced(SLC 모드)로 설정하거나, GP(General Purpose) 파티션을 생성할 수 있습니다. 이 작업은 공장 설정 시 1회만 가능하며 (PARTITION_SETTING_COMPLETED[155] = 1), 이후에는 변경할 수 없습니다.

# Enhanced user data area 생성 (SLC 영역)
# 주의: 1회성 설정이며 전체 용량이 줄어듦
sudo mmc enh_area set -y 0 524288 /dev/mmcblk0  # 시작 0, 512MB

# GP 파티션 생성 (Enhanced 속성 포함)
sudo mmc gp create -y 1 1048576 enh /dev/mmcblk0  # GP1, 1GB, Enhanced

# 설정 완료 (복구 불가!)
sudo mmc write_reliability set -y 1 /dev/mmcblk0

데이터 무결성(Integrity)

eMMC 프로토콜은 여러 계층에서 데이터 무결성을 보장하는 메커니즘을 제공합니다. CRC 보호부터 안정적인 쓰기, 캐시 관리, 백그라운드 작업까지 다양한 기능이 데이터 손실을 방지하고 스토리지 성능을 유지합니다.

CRC 보호

eMMC 프로토콜은 모든 전송에 CRC(순환 중복 검사)를 적용합니다:

• CMD 라인: CRC7 — 48비트 커맨드/응답 프레임의 마지막 7비트
• DAT 라인: CRC16 — 각 DAT 라인별로 독립적인 16비트 CRC
• CRC 에러 발생 시 호스트 컨트롤러가 인터럽트를 생성하고, 커널은 해당 요청을 재시도합니다

Reliable Write

일반 쓰기는 갑작스러운 전원 차단 시 데이터가 일부만 기록될 수 있습니다. Reliable Write는 이를 방지하여 원자적(atomic) 쓰기를 보장합니다.

/* CMD23 (SET_BLOCK_COUNT)의 bit 31을 설정하여 Reliable Write 활성화 */
struct mmc_command cmd = {
    .opcode  = MMC_SET_BLOCK_COUNT,
    .arg     = (1 << 31) | block_count,  /* bit 31 = Reliable Write */
    .flags   = MMC_RSP_R1 | MMC_CMD_AC,
};

/*
 * Reliable Write 동작 방식:
 * - 전원 차단 시 이전 상태 또는 완전히 새 상태 중 하나가 보장됨
 * - 부분 기록(torn write) 방지
 * - 512바이트 단위 원자성 (Reliable Write Size에 따라 다름)
 * - EXT_CSD[166] REL_WR_SEC_C: 최대 Reliable Write 섹터 수
 */

/* 커널에서의 활용: mmc_blk_data_prep() */
if (brq->data.blocks > card->ext_csd.rel_sectors)
    brq->data.blocks = card->ext_csd.rel_sectors;

if (req_op(req) == REQ_OP_WRITE &&
    (req->cmd_flags & REQ_META) &&
    (card->ext_csd.rel_param & EXT_CSD_WR_REL_PARAM_EN))
    brq->sbc.arg |= (1 << 31);  /* Reliable Write flag */

Power-off Notification

eMMC 4.5에서 도입된 POWER_OFF_NOTIFICATION(EXT_CSD[34])은 카드에 전원 차단을 사전 통지하여 내부 캐시를 안전하게 플러시(Flush)할 시간을 제공합니다.

/* drivers/mmc/core/mmc.c — 전원 차단 통지 */
static void mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
{
    unsigned int timeout;

    /* EXT_CSD[34] POWER_OFF_NOTIFICATION 설정 */
    /* notify_type: EXT_CSD_POWER_OFF_SHORT (1) 또는 LONG (2) */
    mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
               EXT_CSD_POWER_OFF_NOTIFICATION,
               notify_type, card->ext_csd.generic_cmd6_time);

    if (notify_type == EXT_CSD_POWER_OFF_SHORT)
        timeout = card->ext_csd.power_off_longtime;  /* 수백 ms */
    else
        timeout = card->ext_csd.power_off_longtime;  /* 최대 수 초 */

    /* 카드가 내부 캐시를 플러시할 때까지 대기 */
    /* 이후 안전하게 VCC/VCCQ 차단 가능 */
}

캐시 관리

eMMC 4.5 이상의 캐시 기능은 쓰기 성능을 크게 향상시키지만, 갑작스러운 전원 차단 시 캐시의 데이터가 손실될 수 있습니다.

/* 캐시 활성화: EXT_CSD[33] CACHE_CTRL = 1 */
int mmc_cache_ctrl(struct mmc_host *host, u8 enable)
{
    struct mmc_card *card = host->card;

    if (!(card->ext_csd.cache_size > 0))
        return 0;  /* 캐시 미지원 */

    return mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                      EXT_CSD_CACHE_CTRL, enable,
                      card->ext_csd.generic_cmd6_time);
}

/* 캐시 플러시: CMD6 → FLUSH_CACHE (EXT_CSD[32] = 1) */
int mmc_flush_cache(struct mmc_card *card)
{
    if (!(card->ext_csd.cache_ctrl & 1))
        return 0;  /* 캐시 비활성 */

    return mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                      EXT_CSD_FLUSH_CACHE, 1,
                      card->ext_csd.cache_flush_timeout);
}

/* barrier flush: REQ_FUA + REQ_PREFLUSH 처리 */
/* blk-mq에서 REQ_FUA 요청 시 mmc_blk_issue_flush()가 캐시 플러시 수행 */

Background Operations (BKOPS)

eMMC 내부의 가비지 컬렉션, 웨어 레벨링 등의 유지보수 작업을 BKOPS(Background Operations)라 합니다. 호스트가 이를 적절히 관리하지 않으면 쓰기 성능이 시간이 지남에 따라 급격히 저하될 수 있습니다.

/* BKOPS 긴급도 수준 (EXT_CSD[246] BKOPS_STATUS) */
#define BKOPS_STATUS_NO_OP          0  /* 유지보수 불필요 */
#define BKOPS_STATUS_NON_CRITICAL   1  /* 비긴급: 여유 시간에 수행 */
#define BKOPS_STATUS_PERF_IMPACT    2  /* 성능 영향: 곧 수행 필요 */
#define BKOPS_STATUS_CRITICAL       3  /* 긴급: 즉시 수행 필요 */

/* 수동 BKOPS 시작: CMD6 → BKOPS_START (EXT_CSD[164] = 1) */
int mmc_start_bkops(struct mmc_card *card)
{
    int err;

    if (!card->ext_csd.man_bkops_en)
        return 0;

    err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                     EXT_CSD_BKOPS_START, 1,
                     MMC_BKOPS_TIMEOUT_MS);
    if (!err)
        card->doing_bkops = true;
    return err;
}

/* 자동 BKOPS: EXT_CSD[163] BKOPS_EN bit 1 설정 */
/* eMMC 5.0+에서 자동 BKOPS가 권장됨 — 카드가 유휴 시 자동 수행 */
int mmc_set_auto_bkops(struct mmc_card *card, bool enable)
{
    return mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                      EXT_CSD_BKOPS_EN,
                      enable ? card->ext_csd.bkops_en | 0x2
                             : card->ext_csd.bkops_en & ~0x2,
                      card->ext_csd.generic_cmd6_time);
}

Write Protection

eMMC는 세 가지 수준의 쓰기 보호를 제공합니다:

• 임시 보호 (Temporary): CMD28/CMD29로 설정/해제, 전원 차단 시 초기화
• 전원 보호 (Power-on): CMD28로 설정, 전원 차단 시 초기화되지만 런타임 중 해제 불가
• 영구 보호 (Permanent): CMD28로 설정, 해제 불가 — 프로덕션 환경에서 주의

/* Write Protection Group Size:
 * WP_GRP_SIZE (CSD) × ERASE_GRP_SIZE 단위로 보호 영역 설정
 * 일반적으로 수 MB 단위
 */

/* 쓰기 보호 설정 */
struct mmc_command cmd = {
    .opcode = MMC_CMD_SET_WRITE_PROT,   /* CMD28 */
    .arg    = sector_addr,              /* WP 그룹 시작 섹터 */
    .flags  = MMC_RSP_R1B | MMC_CMD_AC,
};

/* 쓰기 보호 해제 (임시 보호만 가능) */
struct mmc_command cmd = {
    .opcode = MMC_CMD_CLR_WRITE_PROT,   /* CMD29 */
    .arg    = sector_addr,
    .flags  = MMC_RSP_R1B | MMC_CMD_AC,
};

전원 관리(Power Management)

eMMC의 전원 관리는 카드 상태 머신, 전압 제어, Linux PM 프레임워크가 통합되어 동작합니다. 임베디드 시스템에서 전력 소비 최적화는 배터리 수명에 직결되므로, eMMC의 전원 상태를 적절히 관리하는 것이 중요합니다.

eMMC 카드 상태

eMMC 카드는 MMC 프로토콜에 따라 다음 상태들을 갖습니다:

전원 상태 전환

eMMC의 전원 관련 전환 시퀀스는 다음과 같습니다:

1. Power-off → Pre-idle: VCC 인가 후 CMD0 전송
2. Pre-idle → Idle: CMD0 수신, 내부 레지스터 초기화
3. 활성 → Sleep: CMD7 deselect → CMD5 (Sleep) — VCC 유지, VCCQ 차단 가능
4. Sleep → Power-off: VCC 차단 (VCCQ는 이미 차단되었거나 함께 차단)
5. Sleep → 활성: CMD5 (Awake) → CMD7 select

전압 제어

eMMC는 두 가지 전원 레일을 사용합니다:

• VCC (vmmc-supply): NAND 플래시 전원, 2.7~3.6V (일반적으로 3.3V)
• VCCQ (vqmmc-supply): I/O 인터페이스 전원, 1.7~1.95V 또는 2.7~3.6V

HS200/HS400 모드에서는 1.8V VCCQ가 필수입니다. CMD11 (VOLTAGE_SWITCH)을 통해 3.3V에서 1.8V로 전환하며, Linux에서는 regulator 프레임워크로 관리합니다.

/* drivers/mmc/core/core.c — 전원 관리 */
void mmc_power_up(struct mmc_host *host, u32 ocr)
{
    /* 1단계: VCC(vmmc) 전원 인가 */
    mmc_set_initial_state(host);

    if (!IS_ERR(host->supply.vmmc))
        mmc_regulator_set_ocr(host, host->supply.vmmc, ocr);

    /* 2단계: VCCQ(vqmmc) 전원 인가 */
    if (!IS_ERR(host->supply.vqmmc))
        regulator_enable(host->supply.vqmmc);

    /* 3단계: 클럭 활성화 및 초기 주파수 설정 */
    mmc_set_ios(host);
    mmc_delay(host->ios.power_delay_ms);

    /* 4단계: 클럭 주파수를 초기화 속도(400kHz 이하)로 설정 */
    mmc_set_clock(host, host->f_init);
    mmc_delay(host->ios.power_delay_ms);
}

void mmc_power_off(struct mmc_host *host)
{
    /* 클럭 중지 */
    mmc_set_clock(host, 0);

    /* VCC 차단 */
    if (!IS_ERR(host->supply.vmmc))
        mmc_regulator_set_ocr(host, host->supply.vmmc, 0);

    /* VCCQ 차단 */
    if (!IS_ERR(host->supply.vqmmc))
        regulator_disable(host->supply.vqmmc);

    mmc_set_ios(host);
}

/* Sleep 상태 전환 */
static int mmc_sleep(struct mmc_host *host)
{
    struct mmc_card *card = host->card;
    int err;

    /* CMD7 deselect */
    mmc_deselect_cards(host);

    /* CMD5 with Sleep bit */
    err = mmc_card_sleepawake(host, 1);
    if (err)
        return err;

    /* Sleep 상태에서는 VCCQ 차단 가능 (전력 절감) */
    mmc_set_ios(host);
    return 0;
}

Runtime PM 통합

/* drivers/mmc/core/block.c — Runtime PM */
static int mmc_blk_runtime_suspend(struct mmc_host *host)
{
    /* 큐 중지 + 캐시 플러시 + Sleep 모드 진입 */
    return mmc_power_save_host(host);
}

static int mmc_blk_runtime_resume(struct mmc_host *host)
{
    /* 전원 복구 + 카드 초기화 + 큐 재개 */
    return mmc_power_restore_host(host);
}

/* 호스트 드라이버에서의 사용 */
static int sdhci_runtime_suspend_host(struct sdhci_host *host)
{
    unsigned long flags;

    /* 미완료 요청 대기 */
    mmc_retune_timer_stop(host->mmc);

    spin_lock_irqsave(&host->lock, flags);
    host->ier &= SDHCI_INT_CARD_INT;
    sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
    sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
    spin_unlock_irqrestore(&host->lock, flags);

    synchronize_hardirq(host->irq);

    /* 클럭 게이팅 */
    sdhci_set_clock(host, 0);

    return 0;
}

/* Autosuspend 설정 (sysfs) */
/* /sys/devices/.../power/autosuspend_delay_ms (기본 3000ms) */
/* pm_runtime_set_autosuspend_delay(dev, 3000); */

인라인 암호화

blk-crypto 프레임워크는 eMMC/UFS 컨트롤러의 하드웨어 인라인 암호화 엔진(ICE)을 활용하여 스토리지 I/O를 투명하게 암호화합니다. fscrypt와 통합되어 파일 단위 암호화를 지원하며, 하드웨어 미지원 시 소프트웨어 폴백을 자동 적용합니다.

디바이스 트리 바인딩

ARM/ARM64 기반 임베디드 시스템에서 eMMC 호스트 컨트롤러는 디바이스 트리(Device Tree)를 통해 하드웨어 설정을 기술합니다. 올바른 DT 바인딩은 eMMC 초기화, 속도 모드 협상, 전원 관리의 기반이 됩니다.

표준 mmc-controller 바인딩 속성

Qualcomm (sdhci-msm) DT 예시

/* Qualcomm SDM845 — sdhci-msm with ICE crypto */
sdhc_2: sdhci@8804000 {
    compatible = "qcom,sdm845-sdhci", "qcom,sdhci-msm-v5";
    reg = <0x08804000 0x1000>,     /* HC 레지스터 */
          <0x08805000 0x1000>;     /* CQE 레지스터 */
    reg-names = "hc", "cqhci";

    interrupts = <GIC_SPI 204 IRQ_TYPE_LEVEL_HIGH>;
    interrupt-names = "hc_irq";

    clocks = <&gcc GCC_SDCC2_AHB_CLK>,
             <&gcc GCC_SDCC2_APPS_CLK>,
             <&xo_board>;
    clock-names = "iface", "core", "xo";

    bus-width = <8>;
    max-frequency = <200000000>;    /* 200 MHz */
    non-removable;

    /* 속도 모드 */
    cap-mmc-highspeed;
    mmc-ddr-1_8v;
    mmc-hs200-1_8v;
    mmc-hs400-1_8v;
    mmc-hs400-enhanced-strobe;

    /* 전원 */
    vmmc-supply = <&vreg_l21a_2p95>;    /* VCC 2.95V */
    vqmmc-supply = <&vreg_l13a_1p8>;    /* VCCQ 1.8V */

    /* 핀 컨트롤 */
    pinctrl-names = "default", "sleep";
    pinctrl-0 = <&sdc2_default>;
    pinctrl-1 = <&sdc2_sleep>;

    /* SD/SDIO 프로빙 비활성화 (eMMC 전용) */
    no-sdio;
    no-sd;

    /* Inline Crypto Engine */
    supports-cqe;
    supports-crypto;

    /* QoS */
    qcom,ice-clk-rates = <300000000 150000000>;

    status = "okay";
};

Samsung Exynos (dw_mmc-exynos) DT 예시

/* Samsung Exynos7420 — Synopsys DesignWare MMC */
dwmmc0: mmc@15740000 {
    compatible = "samsung,exynos7-dw-mshc-smu";
    reg = <0x15740000 0x2000>;
    interrupts = <GIC_SPI 245 IRQ_TYPE_LEVEL_HIGH>;

    #address-cells = <1>;
    #size-cells = <0>;

    clocks = <&cmu_fsys CLK_ACLK_MMC0>,
             <&cmu_fsys CLK_SCLK_MMC0>;
    clock-names = "biu", "ciu";

    fifo-depth = <64>;
    card-detect-delay = <200>;

    bus-width = <8>;
    cap-mmc-highspeed;
    mmc-ddr-1_8v;
    mmc-hs200-1_8v;
    mmc-hs400-1_8v;
    non-removable;
    broken-cd;

    vmmc-supply = <&ldo18_reg>;
    vqmmc-supply = <&ldo3_reg>;

    samsung,dw-mshc-ciu-div = <3>;
    samsung,dw-mshc-sdr-timing = <0 4>;
    samsung,dw-mshc-ddr-timing = <2 4>;
    samsung,dw-mshc-hs400-timing = <0 2>;

    pinctrl-names = "default";
    pinctrl-0 = <&sd0_clk &sd0_cmd &sd0_rdqs &sd0_bus1 &sd0_bus4 &sd0_bus8>;

    status = "okay";
};

Rockchip (dwcmshc / sdhci-of-arasan) DT 예시

/* Rockchip RK3588 — Synopsys DWC MSHC */
sdhci: mmc@fe2e0000 {
    compatible = "rockchip,rk3588-dwcmshc";
    reg = <0x0 0xfe2e0000 0x0 0x10000>;
    interrupts = <GIC_SPI 219 IRQ_TYPE_LEVEL_HIGH>;

    clocks = <&cru CCLK_EMMC>,
             <&cru HCLK_EMMC>,
             <&cru ACLK_EMMC>,
             <&cru BCLK_EMMC>,
             <&cru TMCLK_EMMC>;
    clock-names = "core", "bus", "axi", "block", "timer";

    bus-width = <8>;
    max-frequency = <200000000>;
    non-removable;

    cap-mmc-highspeed;
    mmc-ddr-1_8v;
    mmc-hs200-1_8v;
    mmc-hs400-1_8v;
    mmc-hs400-enhanced-strobe;

    vmmc-supply = <&vcc_3v3_s3>;
    vqmmc-supply = <&vcc_1v8_s3>;

    pinctrl-names = "default";
    pinctrl-0 = <&emmc_bus8 &emmc_clk &emmc_cmd
                 &emmc_data_strobe &emmc_rstnout>;

    /* DLL 튜닝 파라미터 (Rockchip 전용) */
    rockchip,txclk-tapnum = <0x6>;

    status = "okay";
};

핀 컨트롤 (pinctrl) 설정

/* Rockchip 핀 컨트롤 예시 */
&pinctrl {
    emmc {
        emmc_bus8: emmc-bus8 {
            rockchip,pins =
                /* DAT0 ~ DAT7 */
                <2 RK_PA0 1 &pcfg_pull_up_drv_level_2>,
                <2 RK_PA1 1 &pcfg_pull_up_drv_level_2>,
                <2 RK_PA2 1 &pcfg_pull_up_drv_level_2>,
                <2 RK_PA3 1 &pcfg_pull_up_drv_level_2>,
                <2 RK_PA4 1 &pcfg_pull_up_drv_level_2>,
                <2 RK_PA5 1 &pcfg_pull_up_drv_level_2>,
                <2 RK_PA6 1 &pcfg_pull_up_drv_level_2>,
                <2 RK_PA7 1 &pcfg_pull_up_drv_level_2>;
        };

        emmc_clk: emmc-clk {
            rockchip,pins =
                <2 RK_PB0 1 &pcfg_pull_up_drv_level_2>;
        };

        emmc_cmd: emmc-cmd {
            rockchip,pins =
                <2 RK_PB1 1 &pcfg_pull_up_drv_level_2>;
        };

        emmc_data_strobe: emmc-data-strobe {
            rockchip,pins =
                <2 RK_PB2 1 &pcfg_pull_none>;
        };

        emmc_rstnout: emmc-rstnout {
            rockchip,pins =
                <2 RK_PB3 1 &pcfg_pull_none>;
        };
    };
};

Sysfs 인터페이스

리눅스 커널은 eMMC/MMC 장치의 상태와 속성을 사용자 공간에서 읽고 제어할 수 있도록 다양한 sysfs 인터페이스를 제공합니다. 이 인터페이스를 활용하면 장치 정보 조회, 건강 상태 모니터링, 동적 설정 변경 등을 쉘 스크립트만으로 수행할 수 있습니다.

MMC 호스트 속성: /sys/class/mmc_host/mmc0/

MMC 호스트 컨트롤러의 런타임 속성을 제어하는 경로입니다. 호스트 컨트롤러 드라이버에 따라 제공되는 속성이 다를 수 있습니다.

MMC 디바이스 속성: /sys/bus/mmc/devices/mmc0:0001/

개별 eMMC 카드의 고유 정보를 읽을 수 있는 경로입니다. CID, CSD, EXT_CSD에서 추출한 정보가 사람이 읽을 수 있는 형태로 제공됩니다.

블록 디바이스 속성: /sys/block/mmcblk0/

eMMC 블록 디바이스의 I/O 관련 속성을 제어하는 표준 블록 레이어 sysfs입니다.

# 장치 기본 정보
cat /sys/block/mmcblk0/size          # 512-byte 섹터 수
cat /sys/block/mmcblk0/ro            # 읽기 전용 여부 (0/1)
cat /sys/block/mmcblk0/removable     # 제거 가능 여부 (eMMC는 0)

# I/O 큐 속성
cat /sys/block/mmcblk0/queue/scheduler       # 현재 I/O 스케줄러
cat /sys/block/mmcblk0/queue/read_ahead_kb   # 미리 읽기 크기
cat /sys/block/mmcblk0/queue/nr_requests     # 최대 대기 요청 수
cat /sys/block/mmcblk0/queue/max_sectors_kb  # 단일 요청 최대 크기
cat /sys/block/mmcblk0/queue/rotational      # 회전형 미디어 (eMMC는 0)

# 부트 파티션 쓰기 보호 해제
echo 0 > /sys/block/mmcblk0boot0/force_ro    # boot0 쓰기 허용
echo 0 > /sys/block/mmcblk0boot1/force_ro    # boot1 쓰기 허용

건강 상태 모니터링

eMMC 5.0 이상에서 제공하는 수명 관련 sysfs 값의 의미는 다음과 같습니다.

#!/bin/bash
# eMMC 건강 상태 모니터링 스크립트
DEVICE="/sys/bus/mmc/devices/mmc0:0001"

if [ ! -d "$DEVICE" ]; then
    echo "eMMC 장치를 찾을 수 없습니다."
    exit 1
fi

echo "=== eMMC 장치 정보 ==="
echo "이름:     $(cat $DEVICE/name)"
echo "제조사:   $(cat $DEVICE/manfid)"
echo "시리얼:   $(cat $DEVICE/serial)"
echo "날짜:     $(cat $DEVICE/date)"
echo ""

echo "=== 수명 정보 ==="
EOL=$(cat $DEVICE/eol_info 2>/dev/null)
LIFE=$(cat $DEVICE/life_time 2>/dev/null)

case "$EOL" in
    0x01) echo "PRE_EOL_INFO: 정상 (예비 블록 충분)" ;;
    0x02) echo "PRE_EOL_INFO: ⚠ 경고 (예비 블록 부족)" ;;
    0x03) echo "PRE_EOL_INFO: ✗ 긴급 (즉시 교체 필요)" ;;
    *)    echo "PRE_EOL_INFO: $EOL (알 수 없음)" ;;
esac

echo "LIFE_TIME: $LIFE"
echo ""

echo "=== 블록 장치 정보 ==="
SIZE_SECTORS=$(cat /sys/block/mmcblk0/size)
SIZE_GB=$(echo "scale=2; $SIZE_SECTORS * 512 / 1073741824" | bc)
echo "용량: ${SIZE_GB}GB ($SIZE_SECTORS sectors)"
echo "읽기전용: $(cat /sys/block/mmcblk0/ro)"
echo "스케줄러: $(cat /sys/block/mmcblk0/queue/scheduler)"

eMMC 수명 및 건강 관리 심화

eMMC는 NAND 플래시 기반이므로 P/E(Program/Erase) 사이클 수명이 유한합니다. JEDEC 표준은 EXT_CSD의 DEVICE_LIFE_TIME_EST_TYP_A/B와 PRE_EOL_INFO 필드를 통해 기본적인 수명 지표를 제공하지만, 제조사별 벤더 커맨드를 활용하면 훨씬 상세한 진단이 가능합니다. 이 섹션에서는 표준 수명 지표와 제조사별 Health Report를 심화 분석합니다.

JEDEC 표준 수명 지표

eMMC 5.0+ 표준이 정의하는 3가지 핵심 수명 필드입니다.

Device Life Time 해석 가이드

Samsung Health Report

Samsung eMMC는 CMD56(GEN_CMD)을 통해 512바이트의 Smart Report를 제공합니다. 표준 EXT_CSD 수명 지표보다 훨씬 상세한 NAND 레벨 정보를 포함합니다.

SanDisk/WD iNAND Health Report

SanDisk iNAND 시리즈는 CMD56 arg=0x110005F9로 Health Report를 읽습니다. 이 포맷은 Micron의 일부 모델에서도 호환됩니다.

# mmc-utils를 이용한 Health Report 읽기 (SanDisk/Micron 호환)
# mmc-utils에 vendor 확장이 포함된 경우:
mmc gen_cmd read /dev/mmcblk0 0x110005F9 /tmp/health.bin

# 원시 데이터 확인
xxd /tmp/health.bin | head -20

# Python으로 파싱하는 예시 스크립트
python3 -c "
import struct, sys
with open('/tmp/health.bin', 'rb') as f:
    data = f.read(512)
    ver = struct.unpack_from('<H', data, 0)[0]
    init_cnt = struct.unpack_from('<H', data, 2)[0]
    read_reclaim = struct.unpack_from('<I', data, 4)[0]
    init_bad = struct.unpack_from('<H', data, 8)[0]
    runtime_bad = struct.unpack_from('<H', data, 10)[0]
    max_pe = struct.unpack_from('<I', data, 12)[0]
    power_cycles = struct.unpack_from('<I', data, 16)[0]
    min_pe = struct.unpack_from('<I', data, 20)[0]
    spare_pct = struct.unpack_from('<I', data, 24)[0]
    print(f'Health Report Version: {ver}')
    print(f'Init Count: {init_cnt}')
    print(f'Read Reclaim: {read_reclaim}')
    print(f'Initial Bad Blocks: {init_bad}')
    print(f'Runtime Bad Blocks: {runtime_bad}')
    print(f'Max P/E Count: {max_pe}')
    print(f'Min P/E Count: {min_pe}')
    print(f'Power Cycles: {power_cycles}')
    print(f'Spare Block Remaining: {spare_pct}%')
"

Micron Health 모니터링

Micron MTFC 시리즈는 CMD56과 더불어 EXT_CSD의 벤더 전용 영역(바이트 270~301)에 추가 Health 정보를 포함하는 경우가 있습니다.

Write Amplification Factor (WAF) 분석

WAF(Write Amplification Factor)는 호스트가 쓴 데이터량 대비 NAND에 실제 기록된 데이터량의 비율입니다. FTL의 Garbage Collection, Wear Leveling 등으로 인해 항상 1.0보다 크며, WAF가 높을수록 eMMC 수명이 빠르게 소모됩니다.

WAF를 줄이는 방법:

• TRIM/DISCARD 활성화: 파일 삭제 시 FTL에 무효 블록을 알려 GC 효율을 높입니다 (mount -o discard 또는 fstrim)
• 쓰기 크기 정렬: eMMC의 Optimal Write Size(EXT_CSD[270])에 맞춰 I/O를 정렬합니다
• Random Write 감소: 저널링 파일시스템(ext4)의 저널 크기를 줄이거나 F2FS를 사용합니다
• tmpfs 활용: /tmp, /var/log 등 빈번한 쓰기 경로를 RAM 기반 tmpfs로 마운트합니다
• Swap 비활성화: eMMC에 Swap을 배치하면 수명이 급격히 단축됩니다

종합 건강 모니터링 스크립트

#!/bin/bash
# eMMC 종합 건강 상태 점검 스크립트

DEVICE="mmc0:0001"
SYSFS="/sys/class/mmc_host/mmc0/${DEVICE}"
BLOCK="/sys/block/mmcblk0"

echo "===== eMMC Health Report ====="
echo "Date: $(date '+%Y-%m-%d %H:%M:%S')"
echo

# 1. 기본 디바이스 정보
echo "--- 디바이스 정보 ---"
MANFID=$(cat ${SYSFS}/manfid)
NAME=$(cat ${SYSFS}/name)
FWREV=$(cat ${SYSFS}/fwrev)
echo "제조사 ID: ${MANFID}"
echo "모델명: ${NAME}"
echo "펌웨어: ${FWREV}"

# 제조사 이름 변환
case ${MANFID} in
    0x000015) VENDOR="Samsung" ;;
    0x000090) VENDOR="SK Hynix" ;;
    0x000013) VENDOR="Micron" ;;
    0x000045) VENDOR="SanDisk/WD" ;;
    0x000011) VENDOR="Toshiba/Kioxia" ;;
    0x000070) VENDOR="Kingston" ;;
    *)        VENDOR="Unknown(${MANFID})" ;;
esac
echo "제조사: ${VENDOR}"
echo

# 2. 수명 지표
echo "--- 수명 지표 ---"
LIFE_A=$(cat ${SYSFS}/life_time 2>/dev/null | awk '{print $1}')
LIFE_B=$(cat ${SYSFS}/life_time 2>/dev/null | awk '{print $2}')
PRE_EOL=$(cat ${SYSFS}/pre_eol_info 2>/dev/null)

# 수치 해석
interpret_life() {
    case $1 in
        0x01) echo "0-10% (양호)" ;;
        0x02) echo "10-20% (양호)" ;;
        0x03) echo "20-30% (양호)" ;;
        0x04) echo "30-40% (보통)" ;;
        0x05) echo "40-50% (보통)" ;;
        0x06) echo "50-60% (주의)" ;;
        0x07) echo "60-70% (주의)" ;;
        0x08) echo "70-80% (경고)" ;;
        0x09) echo "80-90% (위험)" ;;
        0x0a) echo "90-100% (위험)" ;;
        0x0b) echo "초과 (즉시 교체)" ;;
        *)    echo "정보 없음" ;;
    esac
}

echo "Type A (SLC/Enhanced): ${LIFE_A} - $(interpret_life ${LIFE_A})"
echo "Type B (MLC/TLC):      ${LIFE_B} - $(interpret_life ${LIFE_B})"

case ${PRE_EOL} in
    0x01) EOL_STATUS="정상" ;;
    0x02) EOL_STATUS="경고 (80% 소모)" ;;
    0x03) EOL_STATUS="긴급 (즉시 교체)" ;;
    *)    EOL_STATUS="정보 없음" ;;
esac
echo "Pre-EOL: ${PRE_EOL} - ${EOL_STATUS}"
echo

# 3. I/O 통계
echo "--- I/O 통계 ---"
STAT=$(cat ${BLOCK}/stat)
READ_SECTORS=$(echo ${STAT} | awk '{print $3}')
WRITE_SECTORS=$(echo ${STAT} | awk '{print $7}')
READ_GB=$(echo "scale=2; ${READ_SECTORS} * 512 / 1073741824" | bc)
WRITE_GB=$(echo "scale=2; ${WRITE_SECTORS} * 512 / 1073741824" | bc)
echo "누적 읽기: ${READ_GB} GB"
echo "누적 쓰기: ${WRITE_GB} GB (호스트 기준, 부팅 후)"
echo

# 4. 경고 판단
if [[ "${PRE_EOL}" == "0x03" ]] || [[ "${LIFE_A}" > "0x08" ]] || [[ "${LIFE_B}" > "0x08" ]]; then
    echo "⚠ 경고: eMMC 수명이 위험 수준입니다. 즉시 교체를 계획하세요."
    echo "  - 데이터 백업을 우선 수행하세요."
    echo "  - 쓰기 부하를 최소화하세요 (swap 비활성화, 로그 축소)."
elif [[ "${PRE_EOL}" == "0x02" ]] || [[ "${LIFE_A}" > "0x05" ]] || [[ "${LIFE_B}" > "0x05" ]]; then
    echo "⚠ 주의: eMMC 수명 50% 이상 소모. 교체 계획을 수립하세요."
else
    echo "✓ eMMC 수명 상태 양호."
fi

산업용/자동차 eMMC 수명 관리

산업용(Industrial Grade)과 자동차용(Automotive Grade, AEC-Q100) eMMC는 일반 소비자용과 다른 수명 관리 전략이 필요합니다.

디버깅 및 진단

eMMC/MMC 서브시스템 문제를 진단할 때는 커널이 제공하는 다양한 디버깅 도구를 계층별로 활용합니다. 하드웨어 레벨(오실로스코프/로직 분석기)부터 소프트웨어 레벨(커널 로그, tracepoint, debugfs)까지 단계적으로 접근하면 효율적으로 원인을 좁힐 수 있습니다.

mmc_test 커널 모듈(Kernel Module)

mmc_test는 커널에 내장된 MMC 테스트 모듈로, 데이터 무결성, 전송 성능, 에러 처리 등을 하드웨어 레벨에서 검증합니다. 프로덕션이 아닌 개발/디버깅 환경에서만 사용해야 합니다.

# mmc_test 모듈 로드 (해당 eMMC의 블록 드라이버를 unbind 후 사용)
echo mmc0:0001 > /sys/bus/mmc/drivers/mmcblk/unbind
modprobe mmc_test

# 테스트 실행 (test 파일에 테스트 번호 쓰기)
echo mmc0:0001 > /sys/bus/mmc/drivers/mmc_test/bind

# 사용 가능한 테스트 목록 (dmesg에서 확인)
dmesg | grep "mmc_test"

# 특정 테스트 실행
echo 1 > /sys/bus/mmc/drivers/mmc_test/mmc0:0001/test
# 결과 확인
dmesg | tail -20

# 복구: mmc_test unbind 후 mmcblk rebind
echo mmc0:0001 > /sys/bus/mmc/drivers/mmc_test/unbind
echo mmc0:0001 > /sys/bus/mmc/drivers/mmcblk/bind

debugfs 인터페이스

MMC 호스트 컨트롤러는 debugfs에 런타임 상태를 노출합니다.

# debugfs 마운트 확인
mount | grep debugfs
# 없으면: mount -t debugfs none /sys/kernel/debug

# MMC 호스트 debugfs 조회
ls /sys/kernel/debug/mmc0/

# 현재 I/O 설정 확인 (클럭, 버스 폭, 타이밍 모드)
cat /sys/kernel/debug/mmc0/ios
# 출력 예시:
#   clock:          200000000 Hz
#   actual clock:   200000000 Hz
#   vdd:            21 (3.3 ~ 3.4 V)
#   bus mode:       2 (push-pull)
#   chip select:    0 (don't care)
#   power mode:     2 (on)
#   bus width:      3 (8 bits)
#   timing spec:    10 (mmc hs400 enhanced strobe)
#   signal voltage: 1 (1.80 V)
#   driver type:    0 (driver type B)

# 클럭 정보
cat /sys/kernel/debug/mmc0/clock

ftrace Tracepoint

커널의 ftrace 프레임워크는 MMC 요청의 시작과 완료를 추적하는 tracepoint를 제공합니다. 성능 분석이나 타이밍 문제 진단에 매우 유용합니다.

# 사용 가능한 MMC tracepoint 확인
ls /sys/kernel/debug/tracing/events/mmc/

# trace-cmd로 MMC 요청 추적
trace-cmd record -e mmc:mmc_request_start -e mmc:mmc_request_done \
    dd if=/dev/mmcblk0 of=/dev/null bs=4k count=1000
trace-cmd report | head -50

# 수동 ftrace 설정
echo 1 > /sys/kernel/debug/tracing/events/mmc/mmc_request_start/enable
echo 1 > /sys/kernel/debug/tracing/events/mmc/mmc_request_done/enable

# 워크로드 실행 후 결과 확인
cat /sys/kernel/debug/tracing/trace | head -100

# 추적 끄기
echo 0 > /sys/kernel/debug/tracing/events/mmc/enable

mmc-utils 상세 명령

mmc-utils는 eMMC 전용 관리 유틸리티로, EXT_CSD 읽기/쓰기, 쓰기 보호, RPMB, 펌웨어 업데이트 등 다양한 관리 작업을 지원합니다.

# 설치 (소스에서 빌드)
git clone https://git.kernel.org/pub/scm/utils/mmc/mmc-utils.git
cd mmc-utils && make && sudo make install

# EXT_CSD 전체 읽기
mmc extcsd read /dev/mmcblk0

# EXT_CSD 특정 바이트 쓰기 (주의: 잘못된 값은 장치 손상 유발)
# 예: BKOPS_EN (EXT_CSD[163]) 활성화
mmc extcsd write 163 1 /dev/mmcblk0

# 쓰기 보호 상태 확인
mmc writeprotect get /dev/mmcblk0
mmc writeprotect boot get /dev/mmcblk0

# 쓰기 보호 설정
mmc writeprotect boot set /dev/mmcblk0

# RPMB 카운터 읽기
mmc rpmb read-counter /dev/mmcblk0rpmb

# 장치 상태 조회
mmc status get /dev/mmcblk0

# sanitize 실행 (삭제 데이터 물리적 소거)
mmc sanitize /dev/mmcblk0

# FFU (Field Firmware Update) — 펌웨어 파일 필요
mmc ffu <firmware.bin> /dev/mmcblk0

# 캐시 활성화/비활성화
mmc cache enable /dev/mmcblk0
mmc cache disable /dev/mmcblk0

# eMMC 하드웨어 리셋
mmc hwreset enable /dev/mmcblk0

커널 로그 메시지 해석

Dynamic Debug 및 blktrace

# mmc_core 동적 디버그 메시지 활성화
echo "module mmc_core +p" > /sys/kernel/debug/dynamic_debug/control
echo "module sdhci +p" > /sys/kernel/debug/dynamic_debug/control

# 특정 파일의 디버그 활성화
echo "file mmc_ops.c +p" > /sys/kernel/debug/dynamic_debug/control
echo "file sdhci.c +p" > /sys/kernel/debug/dynamic_debug/control

# 활성화된 디버그 포인트 확인
grep "mmc" /sys/kernel/debug/dynamic_debug/control | grep "=p"

# 디버그 메시지 확인
dmesg -w | grep mmc

# blktrace로 블록 I/O 추적
blktrace -d /dev/mmcblk0 -o trace_emmc &
# 워크로드 실행
dd if=/dev/mmcblk0 of=/dev/null bs=1M count=100
# 추적 중지
kill %1
# 분석
blkparse -i trace_emmc -o trace_emmc.txt
# I/O 패턴 시각화
btt -i trace_emmc.blktrace.0 -o btt_result

성능 튜닝

eMMC 성능을 최대한 끌어내려면 하드웨어 설정(버스 폭, 클럭, 타이밍)과 소프트웨어 설정(스케줄러, 큐 깊이, 미리 읽기) 양쪽을 모두 최적화해야 합니다. 아래에서 각 튜닝 포인트를 구체적으로 설명합니다.

클럭 및 버스 폭 최적화

실제 협상된 모드가 기대한 모드인지 먼저 확인해야 합니다. DT에 HS400을 설정했더라도 카드나 호스트 제약으로 HS200이나 High Speed로 폴백될 수 있습니다.

# 현재 협상된 모드 확인
cat /sys/kernel/debug/mmc0/ios
# 핵심 필드:
#   clock:      200000000 (200MHz = HS400)
#   bus width:  3 (8 bits)
#   timing:     10 (mmc hs400 enhanced strobe)

# 타이밍 모드 번호 해석:
# 0=legacy, 1=mmc HS, 2=SD HS, 3=SDR12, 4=SDR25
# 5=SDR50, 6=SDR104, 7=DDR50, 8=DDR52
# 9=HS200, 10=HS400, 11=HS400ES

CMDQ (Command Queue) 활성화

eMMC 5.1의 CMDQ는 최대 32개의 명령을 큐에 넣어 병렬 I/O를 수행합니다. 카드 내부 컨트롤러가 명령 순서를 최적화하여 랜덤 I/O 성능이 크게 향상됩니다.

# CMDQ 지원 여부 확인
mmc extcsd read /dev/mmcblk0 | grep CMDQ
# CMDQ_SUPPORT [308]: 0x01  → 지원함
# CMDQ_DEPTH [307]: 0x20    → 32 슬롯

# CMDQ 활성화 확인
mmc extcsd read /dev/mmcblk0 | grep CMDQ_MODE_EN
# CMDQ_MODE_EN [15]: 0x01   → 활성화됨

# 커널 로그에서 CMDQ 확인
dmesg | grep -i cmdq
# mmc0: Command Queue Engine enabled

DMA 모드 최적화

SDHCI 호스트는 SDMA, ADMA1, ADMA2 세 가지 DMA 모드를 지원합니다. ADMA2가 scatter-gather를 지원하여 가장 효율적이며, 대부분의 현대 SoC에서 기본 선택됩니다.

# 현재 DMA 모드 확인 (커널 로그)
dmesg | grep -i "sdhci.*dma"
# sdhci-pltfm: SDHCI platform driver (ADMA 64-bit)

I/O 스케줄러 설정

eMMC는 비회전형 플래시 스토리지이므로, 탐색 시간(seek time) 최적화를 수행하는 bfq 스케줄러는 불필요한 오버헤드를 추가합니다. mq-deadline 또는 none이 적합합니다.

# 현재 스케줄러 확인
cat /sys/block/mmcblk0/queue/scheduler
# [mq-deadline] kyber bfq none

# mq-deadline으로 변경
echo mq-deadline > /sys/block/mmcblk0/queue/scheduler

# CMDQ 활성 상태에서는 none이 최적 (카드 내부에서 스케줄링)
echo none > /sys/block/mmcblk0/queue/scheduler

Read-ahead 튜닝

# 현재 미리 읽기 크기 확인 (기본 128KB)
cat /sys/block/mmcblk0/queue/read_ahead_kb

# 순차 읽기 워크로드: 미리 읽기 증가
echo 2048 > /sys/block/mmcblk0/queue/read_ahead_kb

# 랜덤 읽기 워크로드: 미리 읽기 감소 (불필요한 I/O 방지)
echo 16 > /sys/block/mmcblk0/queue/read_ahead_kb

fio 벤치마크

# 1. 순차 읽기 테스트
fio --name=seq_read --filename=/dev/mmcblk0 --direct=1 \
    --rw=read --bs=512k --numjobs=1 --iodepth=32 \
    --runtime=30 --time_based --group_reporting

# 2. 순차 쓰기 테스트
fio --name=seq_write --filename=/dev/mmcblk0 --direct=1 \
    --rw=write --bs=512k --numjobs=1 --iodepth=32 \
    --runtime=30 --time_based --group_reporting

# 3. 랜덤 4K 읽기 테스트
fio --name=rand_read_4k --filename=/dev/mmcblk0 --direct=1 \
    --rw=randread --bs=4k --numjobs=4 --iodepth=32 \
    --runtime=30 --time_based --group_reporting

# 4. 랜덤 4K 쓰기 테스트
fio --name=rand_write_4k --filename=/dev/mmcblk0 --direct=1 \
    --rw=randwrite --bs=4k --numjobs=4 --iodepth=32 \
    --runtime=30 --time_based --group_reporting

BKOPS (Background Operations)

BKOPS는 eMMC 내부의 가비지 컬렉션, 웨어 레벨링 등 유지보수 작업입니다. 자동 BKOPS(BKOPS_EN)를 활성화하면 카드가 유휴 시 자동으로 수행하지만, 시간 민감한 워크로드에서는 수동 트리거가 유리할 수 있습니다.

# BKOPS 상태 확인
mmc extcsd read /dev/mmcblk0 | grep BKOPS
# BKOPS_EN [163]: 0x01          → 자동 BKOPS 활성화됨
# BKOPS_STATUS [246]: 0x00      → 미수행 필요
# BKOPS_STATUS 값:
#   0x00 = 작업 불필요
#   0x01 = 비긴급 (성능 영향 없음)
#   0x02 = 성능 영향 가능 (조만간 수행 권장)
#   0x03 = 긴급 (즉시 수행 필요, 성능 저하 발생 중)

# 수동 BKOPS 트리거 (EXT_CSD BKOPS_START[164] = 1)
mmc extcsd write 164 1 /dev/mmcblk0

Pack Command

Pack Command는 여러 개의 작은 쓰기 요청을 하나의 큰 전송으로 묶어 프로토콜 오버헤드를 줄이는 기능입니다. eMMC 4.5 이상에서 지원되며, 커널의 MMC 블록 드라이버가 자동으로 활용합니다.

# Pack Command 지원 확인
mmc extcsd read /dev/mmcblk0 | grep PACKED
# PACKED_COMMAND_MAX_SIZE [166]: 0x08  → 8개까지 묶기 가능

성능 튜닝 체크리스트

UFS 비교

UFS(Universal Flash Storage)는 eMMC의 후속으로 개발된 플래시 스토리지 표준입니다. 두 기술은 동일한 NAND 플래시 기반이지만 인터페이스 아키텍처가 근본적으로 다릅니다. eMMC는 병렬 버스, UFS는 직렬 고속 인터페이스를 사용합니다.

아키텍처 비교

eMMC는 8-bit 병렬 데이터 버스에 반이중(half-duplex) 통신을 사용합니다. 반면 UFS는 MIPI M-PHY 물리 계층과 UniPro 전송 계층 위에 SCSI 기반 UFS 프로토콜을 실행하며, 2개의 차동 레인으로 전이중(full-duplex) 통신을 합니다.

성능 비교

기능 비교

선택 기준

마이그레이션 고려사항

eMMC에서 UFS로 전환할 때 주요 변경 사항:

• 드라이버 변경: MMC 서브시스템(drivers/mmc/) 대신 SCSI + UFS 서브시스템(drivers/ufs/)을 사용합니다. 블록 장치(Block Device) 이름이 mmcblk0에서 sda로 변경됩니다.
• DT 변경: sdhci 호환 노드 대신 ufs-hci 호환 노드를 사용합니다. 레인 수, 기어(Gear) 설정 등 M-PHY 관련 속성이 추가됩니다.
• 파티션 구조: eMMC의 하드웨어 파티션(boot0/boot1/RPMB/User) 대신 UFS의 LU(Logical Unit) 개념으로 전환합니다. 부트로더 저장 위치와 RPMB 접근 방식이 달라집니다.
• 유저스페이스 도구: mmc-utils 대신 ufs-utils를 사용합니다.

자주 겪는 문제와 해결

eMMC 개발 및 운영에서 자주 겪는 문제와 체계적인 해결 방법을 정리합니다. 각 문제에 대해 증상, 원인, 해결 방법, 진단 명령을 포함합니다.

진단 명령 모음

# 1. 기본 상태 확인
dmesg | grep -i mmc                          # 커널 로그에서 MMC 관련 메시지
lsblk -o NAME,SIZE,TYPE,MOUNTPOINT,TRAN      # 블록 장치 목록
cat /sys/kernel/debug/mmc0/ios               # 현재 I/O 설정

# 2. 카드 정보 확인
cat /sys/bus/mmc/devices/mmc0:0001/name      # 제품 이름
cat /sys/bus/mmc/devices/mmc0:0001/cid       # CID 원시값
mmc extcsd read /dev/mmcblk0 | head -50      # EXT_CSD 주요 필드

# 3. 수명/건강 확인
cat /sys/bus/mmc/devices/mmc0:0001/life_time  # 수명 추정치
cat /sys/bus/mmc/devices/mmc0:0001/eol_info   # EOL 상태

# 4. 에러 카운트 확인
cat /sys/block/mmcblk0/stat                   # I/O 통계
# 필드: read_ios read_merges read_sectors read_ticks
#       write_ios write_merges write_sectors write_ticks
#       in_flight io_ticks time_in_queue

# 5. 튜닝 상태 확인
dmesg | grep -i "tuning\|retune"             # 튜닝 관련 메시지

# 6. 전원 상태 확인
cat /sys/bus/mmc/devices/mmc0:0001/power/runtime_status
cat /sys/bus/mmc/devices/mmc0:0001/power/runtime_active_time

# 7. 호스트 컨트롤러 정보
cat /sys/class/mmc_host/mmc0/device/uevent

관련 문서

eMMC/MMC 서브시스템을 더 깊이 이해하거나 관련 기술을 학습할 때 참고할 문서를 정리합니다.

내부 문서 (사이트 내)

외부 참고 자료

JEDEC 표준 및 사양

• JEDEC JESD84-B51A: eMMC 5.1 표준 사양서 — 커맨드, 레지스터, 타이밍, 파티션, RPMB 등 전체 프로토콜 정의
• JEDEC JESD84-B50A: eMMC 5.0 표준 — CMDQ 최초 정의, BKOPS, Cache 기능 추가
• SD Host Controller Simplified Specification v4.20: SDHCI 레지스터 맵, ADMA 디스크립터, 인터럽트 처리, CQE 확장 정의
• JEDEC UFS (JESD220): UFS 표준 사양서 — eMMC 후속 기술 비교 학습에 유용
• JEDEC eMMC 표준 페이지 — eMMC 관련 JEDEC 표준 문서 목록 및 정보를 제공합니다

커널 공식 문서

• 커널 공식 MMC 서브시스템 문서 — 리눅스 커널 MMC/SD/SDIO 프레임워크의 공식 문서입니다
• 커널 Documentation/mmc/: mmc-dev-attrs.rst (sysfs 속성), mmc-dev-parts.rst (파티션), mmc-tools.rst (유틸리티)
• 커널 Documentation/devicetree/bindings/mmc/: 호스트 컨트롤러별 DT 바인딩 사양 — sdhci-msm.yaml, synopsys-dw-mshc.yaml, mtk-sd.yaml 등

커널 소스 (Bootlin Elixir)

• drivers/mmc/ — MMC 코어, 호스트 드라이버 소스 코드를 온라인에서 탐색할 수 있습니다
• drivers/mmc/core/mmc.c — eMMC 카드 초기화 시퀀스(mmc_init_card)의 핵심 코드입니다
• drivers/mmc/core/quirks.h — 제조사별 eMMC quirk/fixup 테이블 정의입니다
• drivers/mmc/host/cqhci.c — CQHCI(Command Queue Host Controller Interface) 공통 드라이버입니다
• drivers/mmc/host/sdhci.c — SD Host Controller 공통 드라이버의 핵심 구현입니다
• drivers/mmc/host/sdhci-msm.c — Qualcomm SDHCI 호스트 드라이버 (ICE, HS400 DLL 캘리브레이션)
• drivers/mmc/host/dw_mmc.c — Synopsys DesignWare MMC 호스트 드라이버 (IDMAC, Phase 튜닝)
• drivers/mmc/host/mtk-sd.c — MediaTek MSDC 호스트 드라이버 (PAD 딜레이 튜닝)

기술 문서 및 참고 자료

• LWN: Multi-queue for MMC (2016) — MMC 서브시스템의 blk-mq 전환 과정을 다루는 기사입니다
• LWN: Command queueing for eMMC (2017) — eMMC CMDQ 기능의 커널 지원 구현을 설명합니다
• mmc(1) man page — mmc-utils 도구의 사용법 레퍼런스입니다
• Samsung eMMC Data Sheet: KLMAG/KLMBG 시리즈 — Smart Report CMD56 포맷, 전기적 특성, P/E 사이클 보증
• SanDisk iNAND Application Note: Health Report CMD56 arg(0x110005F9) 포맷 정의, 수명 추정 알고리즘
• Micron TN-FC-32: eMMC Health Status Report 기술 노트 — CMD56 포맷, BKOPS 최적화 가이드

커널 소스 읽기 순서

eMMC 서브시스템을 소스 코드 레벨에서 이해하려면 다음 순서로 읽는 것을 권장합니다.

1단계: 핵심 자료구조와 초기화

1. include/linux/mmc/host.h — struct mmc_host 정의, mmc_host_ops 콜백 인터페이스
2. include/linux/mmc/card.h — struct mmc_card 정의, 카드 속성, quirk 플래그
3. include/linux/mmc/mmc.h — MMC 커맨드/레지스터 상수, EXT_CSD 오프셋 정의
4. drivers/mmc/core/core.c — MMC 코어 초기화, 전원/클럭 관리, 재튜닝
5. drivers/mmc/core/mmc.c — mmc_init_card() — eMMC 카드 초기화 시퀀스 전체
6. drivers/mmc/core/mmc_ops.c — 개별 MMC 커맨드 실행 함수 (mmc_send_ext_csd 등)

2단계: 블록 디바이스와 요청 처리

7. drivers/mmc/core/block.c — 블록 디바이스 인터페이스 (mmcblk), TRIM/DISCARD 처리
8. drivers/mmc/core/queue.c — blk-mq 큐 설정, 요청 디스패치
9. drivers/mmc/core/quirks.h — 제조사별 quirk/fixup 테이블 — CID 매칭 로직

3단계: SDHCI 프레임워크

10. drivers/mmc/host/sdhci.c — SDHCI 공통 드라이버 (레지스터 I/O, ADMA, 인터럽트)
11. drivers/mmc/host/sdhci.h — SDHCI 레지스터 오프셋, quirk 플래그 정의
12. drivers/mmc/host/sdhci-pltfm.c — SDHCI 플랫폼 드라이버 공통 유틸리티

4단계: CQHCI와 호스트 드라이버

13. drivers/mmc/host/cqhci.c / cqhci.h — CMDQ 호스트 컨트롤러 인터페이스 공통 구현
14. drivers/mmc/host/cqhci-crypto.c — CQHCI 인라인 암호화 확장
15. drivers/mmc/host/sdhci-msm.c — Qualcomm 호스트 드라이버 (ICE, DLL 캘리브레이션)
16. drivers/mmc/host/dw_mmc.c — Synopsys DesignWare 코어 (IDMAC, FIFO 관리)
17. drivers/mmc/host/mtk-sd.c — MediaTek MSDC (PAD 딜레이, 독자 DMA)
18. drivers/mmc/host/sdhci-esdhc-imx.c — NXP i.MX uSDHC (Strobe DLL, Auto-Tuning)
19. drivers/mmc/host/renesas_sdhi_core.c — Renesas SDHI (SCC TAP 튜닝)