Ch 11: Linux drivers/cxl/ 분석 — Mainline kernel CXL 구현

1
drivers/cxl/
2
├── Kconfig·Makefile
3
├── acpi.c        — cxl_acpi: ACPI CEDT 파싱, root port 등록
4
├── pci.c         — cxl_pci: PCI subsystem 통합, MMIO 매핑
5
├── mem.c         — cxl_mem: memory device driver
6
├── pmem.c        — cxl_pmem: persistent CXL
7
├── port.c        — cxl_port: switch·root port driver
8
└── core/         — cxl_core: 공통 베이스
9
    ├── port.c    — CXL port·decoder 객체
10
    ├── region.c  — region 생성·관리
11
    ├── memdev.c  — memory device 추상화
12
    ├── hdm.c     — HDM Decoder 프로그래밍
13
    ├── mbox.c    — Mailbox API
14
    ├── regs.c    — register access helpers
15
    └── pmem.c    — persistent memory 통합

1
int cxl_decoder_commit(struct cxl_decoder *cxld)
2
{
3
    void __iomem *hdm = cxld->hdm_reg_base;
4

5
    down_write(&cxl_decoder_rwsem);
6

7
    if (cxld->flags & CXL_DECODER_F_ENABLE) {
8
        rc = -EBUSY;
9
        goto out;
10
    }
11

12
    // SPA range 쓰기
13
    writel(lower_32_bits(cxld->hpa_range.start),
14
           hdm + CXL_HDM_DECODER_BASE_LOW(0));
15
    writel(upper_32_bits(cxld->hpa_range.start),
16
           hdm + CXL_HDM_DECODER_BASE_HIGH(0));
17

18
    // Interleave 설정
19
    u32 ctrl = FIELD_PREP(CXL_HDM_DECODER_IW_MASK,
20
                          cxld->interleave_ways) |
21
               FIELD_PREP(CXL_HDM_DECODER_IG_MASK,
22
                          cxld->interleave_granularity);
23
    writel(ctrl, hdm + CXL_HDM_DECODER_CTRL(0));
24

25
    // Commit
26
    writel(ctrl | CXL_HDM_DECODER_ENABLE,
27
           hdm + CXL_HDM_DECODER_CTRL(0));
28

29
    // Polling for commit completion
30
    rc = readl_poll_timeout(hdm + CXL_HDM_DECODER_CTRL(0), val,
31
                            (val & CXL_HDM_DECODER_COMMITTED),
32
                            10, COMMIT_TIMEOUT_US);
33
    if (rc == 0)
34
        cxld->flags |= CXL_DECODER_F_ENABLE;
35

36
out:
37
    up_write(&cxl_decoder_rwsem);
38
    return rc;
39
}

1
int cxl_internal_send_cmd(struct cxl_mailbox *cxl_mbox,
2
                          struct cxl_mbox_cmd *cmd)
3
{
4
    mutex_lock(&cxl_mbox->mbox_mutex);
5

6
    // 명령 검증
7
    if (cmd->size_in > cxl_mbox->payload_size) {
8
        rc = -E2BIG;
9
        goto out;
10
    }
11

12
    // Payload write
13
    if (cmd->payload_in)
14
        memcpy_toio(cxl_mbox->payload_in_base,
15
                    cmd->payload_in, cmd->size_in);
16

17
    // Command 실행
18
    rc = cxl_mbox->mbox_send(cxl_mbox, cmd);
19
    if (rc) goto out;
20

21
    // Completion 대기 (timeout 포함)
22
    rc = wait_for_completion_timeout(
23
        &cxl_mbox->mbox_done,
24
        msecs_to_jiffies(cmd->timeout_ms ?: 2000));
25
    if (rc == 0) {
26
        rc = -ETIMEDOUT;
27
        goto out;
28
    }
29

30
    // Response copy
31
    if (cmd->payload_out && cmd->size_out)
32
        memcpy_fromio(cmd->payload_out,
33
                      cxl_mbox->payload_out_base,
34
                      cmd->size_out);
35

36
    rc = cmd->return_code;
37
out:
38
    mutex_unlock(&cxl_mbox->mbox_mutex);
39
    return rc;
40
}

1
static int cxl_region_attach(struct cxl_region *cxlr,
2
                              struct cxl_endpoint_decoder *cxled,
3
                              int pos)
4
{
5
    // 매핑 추가
6
    cxlr->params.targets[pos] = cxled;
7

8
    // 모든 target 결정 후
9
    if (all_targets_set(cxlr)) {
10
        // NUMA node 할당
11
        int target_nid = cxl_region_pick_node(cxlr);
12

13
        // Memory hot-add
14
        rc = add_memory_driver_managed(target_nid,
15
            cxlr->res.start,
16
            resource_size(&cxlr->res),
17
            "System RAM (CXL)",
18
            MHP_MERGE_RESOURCE);
19
        if (rc) return rc;
20

21
        // NUMA node sysfs 노출
22
        register_one_node(target_nid);
23

24
        // HMAT-based tier 분류
25
        node_to_memory_tier(target_nid);
26
    }
27
    return 0;
28
}

1
static const struct pci_error_handlers cxl_error_handlers = {
2
    .error_detected = cxl_error_detected,
3
    .mmio_enabled   = cxl_mmio_enabled,
4
    .slot_reset     = cxl_slot_reset,
5
    .resume         = cxl_resume,
6
};
7

8
static pci_ers_result_t cxl_error_detected(
9
    struct pci_dev *pdev,
10
    pci_channel_state_t state)
11
{
12
    struct cxl_dev_state *cxlds = pci_get_drvdata(pdev);
13

14
    if (state == pci_channel_io_perm_failure) {
15
        // Fatal — device offline
16
        cxl_memdev_offline(cxlds);
17
        return PCI_ERS_RESULT_DISCONNECT;
18
    }
19
    cxl_mem_get_event_records(cxlds);
20
    return PCI_ERS_RESULT_NEED_RESET;
21
}