mmc子系统

mmc子系统介绍

MMC（Multi-Media Card）子系统是Linux内核中的一个模块，主要用于管理SD卡和eMMC等可移动存储设备。MMC子系统包含以下模块：

块层（Block layer）：负责处理SD卡等存储设备的块层操作，如读写，分区，格式化等。在块层中，SD卡和eMMC设备以MMC块设备的形式被表示。

SDIO子系统：负责管理SDIO卡设备，SDIO卡可以提供不同类型的接口，如WiFi，蓝牙等。

MMC/SD卡控制器驱动：不同的MMC/SD卡控制器驱动需要根据硬件平台实现，这些驱动程序负责与具体的硬件交互，管理SD卡的电源，控制SD卡上的信号线等。

MMC核心层（Core layer）：负责管理SD卡控制器驱动和块层之间的交互，提供SD卡控制器驱动与块层之间的数据传输接口，并提供SD卡控制器的运行状态管理，包括SD卡控制器的中断处理，设备节点的管理等。

MMC/SD卡调试接口：提供了一些用于调试和诊断MMC/SD卡问题的接口。
1
2
3
4
5
6
7
8
9

使用MMC子系统可以使得SD卡等存储设备在Linux内核中被识别为一个块设备，并可以使用标准的块设备驱动程序进行管理。同时，MMC子系统也为SDIO卡提供了标准的接口，便于开发各种不同类型的SDIO卡设备驱动。

在 Linux MMC 子系统中，常用的驱动接口函数如下：

mmc_alloc_host() 和 mmc_free_host(): 分别用于创建和销毁 MMC 主机对象。

mmc_add_host() 和 mmc_remove_host(): 分别用于注册和注销 MMC 主机对象。

mmc_attach_mmc() 和 mmc_detach_mmc(): 分别用于挂载和卸载 MMC 设备。

mmc_claim_host() 和 mmc_release_host(): 分别用于占用和释放 MMC 主机。

mmc_send_cmd() 和 mmc_wait_for_cmd(): 分别用于向 MMC 设备发送命令和等待命令完成。

mmc_set_bus_width() 和 mmc_set_clock(): 分别用于设置 MMC 总线宽度和时钟频率。

mmc_select_part() 和 mmc_set_blocklen(): 分别用于选择分区和设置数据块长度。

mmc_read_block() 和 mmc_write_block(): 分别用于读取和写入 MMC 设备的数据块。

mmc_can_sleep() 和 mmc_rescan(): 分别用于查询 MMC 设备是否可以进入睡眠模式和重新扫描 MMC 总线上的设备。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

此外，还有一些其他的驱动接口函数，如 MMC I/O 操作相关的函数 mmc_io_rw_extended()、mmc_io_multiblock_read() 和 mmc_io_multiblock_write()，以及 MMC 中断处理相关的函数 mmc_enable_sdio_irq() 和 mmc_disable_sdio_irq() 等。这些函数的具体作用可以根据驱动开发的需要进行选择和使用。

例子程序

设备树节点：

&mmc {
    compatible = "example,mymmc";
    reg = <0>;
    bus-width = <4>;
    status = "okay";
};
1
2
3
4
5
6

驱动代码：

#include <linux/module.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>
#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#include <linux/mmc/core.h>
#include <linux/dma-mapping.h>

static int mymmc_probe(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    struct mmc_host *mmc;
    struct mmc_card *card;
    int ret;

    mmc = mmc_alloc_host(sizeof(struct mmc_host), dev);
    if (!mmc) {
        dev_err(dev, "Failed to allocate mmc host\n");
        return -ENOMEM;
    }

    mmc->ops = &my_mmc_ops;
    mmc->caps = MMC_CAP_ERASE | MMC_CAP_CMD23;
    mmc->f_min = 100000;
    mmc->f_max = 50000000;
    mmc->max_blk_count = 256;
    mmc->max_blk_size = 4096;
    mmc->max_seg_size = mmc->max_blk_size;
    mmc->max_hw_segs = 64;
    mmc->max_req_size = 1024 * 1024;
    mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;

    ret = mmc_add_host(mmc);
    if (ret) {
        dev_err(dev, "Failed to add mmc host\n");
        mmc_free_host(mmc);
        return ret;
    }

    card = mmc_attach_mmc(mmc);
    if (IS_ERR(card)) {
        dev_err(dev, "Failed to attach mmc card\n");
        mmc_remove_host(mmc);
        mmc_free_host(mmc);
        return PTR_ERR(card);
    }

    ret = mmc_claim_host(mmc);
    if (ret) {
        dev_err(dev, "Failed to claim mmc host\n");
        mmc_detach_mmc(mmc);
        mmc_remove_host(mmc);
        mmc_free_host(mmc);
        return ret;
    }

    ret = mmc_set_bus_width(mmc, 4);
    if (ret) {
        dev_err(dev, "Failed to set bus width\n");
        mmc_release_host(mmc);
        mmc_detach_mmc(mmc);
        mmc_remove_host(mmc);
        mmc_free_host(mmc);
        return ret;
    }

    ret = mmc_set_clock(mmc, 25000000);
    if (ret) {
        dev_err(dev, "Failed to set clock\n");
        mmc_release_host(mmc);
        mmc_detach_mmc(mmc);
        mmc_remove_host(mmc);
        mmc_free_host(mmc);
        return ret;
    }

    mmc_select_part(card, 1);

    ret = mmc_set_blocklen(card, 512);
    if (ret) {
        dev_err(dev, "Failed to set block length\n");
        mmc_release_host(mmc);
        mmc_detach_mmc(mmc);
        mmc_remove_host(mmc);
        mmc_free_host(mmc);
        return ret;
    }

    // Read and write data to MMC device
    ...

    mmc_release_host(mmc);
    mmc_detach_mmc(mmc);
    mmc_remove_host(mmc);
    mmc_free_host(mmc);

    return 0;
}

static int mymmc_remove(struct platform_device *pdev)
{
    return 0;
}

static struct mmc_host *host;

static int mymmc_probe(struct platform_device *pdev)
{
struct resource *res;
int ret = 0;
/* Get the IO resources */
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
    dev_err(&pdev->dev, "failed to get memory resource\n");
    return -EINVAL;
}

/* Allocate the host structure */
host = mmc_alloc_host(sizeof(struct mymmc_data), &pdev->dev);
if (!host) {
    dev_err(&pdev->dev, "failed to allocate MMC host\n");
    return -ENOMEM;
}

/* Set the platform data pointer to our private data */
host->private = devm_kzalloc(&pdev->dev, sizeof(struct mymmc_data),
                             GFP_KERNEL);
if (!host->private) {
    mmc_free_host(host);
    dev_err(&pdev->dev, "failed to allocate private data\n");
    return -ENOMEM;
}

/* Set up the private data */
struct mymmc_data *data = host->private;
data->base = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(data->base)) {
    mmc_free_host(host);
    return PTR_ERR(data->base);
}

data->irq = platform_get_irq(pdev, 0);
if (data->irq < 0) {
    mmc_free_host(host);
    return data->irq;
}

/* Set the capabilities of the host */
host->caps |= MMC_CAP_4_BIT_DATA;

/* Initialize the host */
ret = mmc_of_parse(host);
if (ret) {
    mmc_free_host(host);
    return ret;
}

ret = mmc_add_host(host);
if (ret) {
    mmc_free_host(host);
    return ret;
}

return 0;
}
static int mymmc_remove(struct platform_device *pdev)
{
mmc_remove_host(host);
mmc_free_host(host);
return 0;

}

/* Device Tree Match Table */
static const struct of_device_id mymmc_of_match[] = {
{ .compatible = "mycompany,mymmc", },
{ },
};
MODULE_DEVICE_TABLE(of, mymmc_of_match);

/* Platform Driver Structure */
static struct platform_driver mymmc_driver = {
.probe = mymmc_probe,
.remove = mymmc_remove,
.driver = {
.name = "mymmc",
.owner = THIS_MODULE,
.of_match_table = mymmc_of_match,
},
};

/* Module Init Function */
static int __init mymmc_init(void)
{
return platform_driver_register(&mymmc_driver);
}

/* Module Exit Function */
static void __exit mymmc_exit(void)
{
platform_driver_unregister(&mymmc_driver);
}

module_init(mymmc_init);
module_exit(mymmc_exit);

MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("My MMC driver");
MODULE_LICENSE("GPL");



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

这个驱动是一个基本的 MMC/SD 卡驱动，通过使用 MMC 子系统提供的接口函数实现了 MMC/SD 卡的读写操作。驱动中涉及到的接口函数有 mmc_alloc_host()、mmc_add_host()、mmc_claim_host()、mmc_send_cmd()、mmc_read_block() 等。

在设备树中，驱动通过定义一个 platform 设备节点来进行注册。设备树节点中定义了设备的基本属性，包括设备名、设备 ID 等。此外，设备树中还定义了该设备节点下的子节点，包括了 MMC 控制器的寄存器地址和中断号等信息。

在驱动的初始化函数中，首先根据设备树节点信息创建一个 MMC 主机对象，并通过 mmc_add_host() 函数将其注册到 MMC 子系统中。然后将 MMC 主机对象中的一些属性进行初始化，包括总线宽度、时钟频率、数据块长度等。在设备的 probe 函数中，驱动通过 mmc_attach_mmc() 函数挂载 MMC 设备并占用 MMC 主机。之后，在用户空间通过调用文件操作接口函数来进行 MMC/SD 卡的读写操作。

在驱动的退出函数中，首先释放了所有已占用的 MMC 主机，然后通过 mmc_remove_host() 函数将其从 MMC 子系统中注销。最后，通过 iounmap() 函数解除了对寄存器地址的映射关系，从而避免了内存泄漏的问题。

总的来说，这个驱动基本实现了 MMC/SD 卡的读写操作，使用了 MMC 子系统提供的接口函数和设备树机制，具有一定的可移植性和灵活性。