Commit | Line | Data |
---|---|---|
6edd8ee6 HS |
1 | /* |
2 | * Debugfs support for hosts and cards | |
3 | * | |
4 | * Copyright (C) 2008 Atmel Corporation | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License version 2 as | |
8 | * published by the Free Software Foundation. | |
9 | */ | |
3f102ae9 | 10 | #include <linux/moduleparam.h> |
3ef77af1 | 11 | #include <linux/export.h> |
6edd8ee6 HS |
12 | #include <linux/debugfs.h> |
13 | #include <linux/fs.h> | |
14 | #include <linux/seq_file.h> | |
5a0e3ad6 | 15 | #include <linux/slab.h> |
6edd8ee6 | 16 | #include <linux/stat.h> |
1b676f70 | 17 | #include <linux/fault-inject.h> |
6edd8ee6 | 18 | |
f4b7f927 | 19 | #include <linux/mmc/card.h> |
6edd8ee6 HS |
20 | #include <linux/mmc/host.h> |
21 | ||
22 | #include "core.h" | |
f4b7f927 | 23 | #include "mmc_ops.h" |
6edd8ee6 | 24 | |
34f50508 PF |
25 | #ifdef CONFIG_FAIL_MMC_REQUEST |
26 | ||
27 | static DECLARE_FAULT_ATTR(fail_default_attr); | |
28 | static char *fail_request; | |
29 | module_param(fail_request, charp, 0); | |
30 | ||
31 | #endif /* CONFIG_FAIL_MMC_REQUEST */ | |
32 | ||
6edd8ee6 HS |
33 | /* The debugfs functions are optimized away when CONFIG_DEBUG_FS isn't set. */ |
34 | static int mmc_ios_show(struct seq_file *s, void *data) | |
35 | { | |
36 | static const char *vdd_str[] = { | |
37 | [8] = "2.0", | |
38 | [9] = "2.1", | |
39 | [10] = "2.2", | |
40 | [11] = "2.3", | |
41 | [12] = "2.4", | |
42 | [13] = "2.5", | |
43 | [14] = "2.6", | |
44 | [15] = "2.7", | |
45 | [16] = "2.8", | |
46 | [17] = "2.9", | |
47 | [18] = "3.0", | |
48 | [19] = "3.1", | |
49 | [20] = "3.2", | |
50 | [21] = "3.3", | |
51 | [22] = "3.4", | |
52 | [23] = "3.5", | |
53 | [24] = "3.6", | |
54 | }; | |
55 | struct mmc_host *host = s->private; | |
56 | struct mmc_ios *ios = &host->ios; | |
57 | const char *str; | |
58 | ||
59 | seq_printf(s, "clock:\t\t%u Hz\n", ios->clock); | |
df16219f GC |
60 | if (host->actual_clock) |
61 | seq_printf(s, "actual clock:\t%u Hz\n", host->actual_clock); | |
6edd8ee6 HS |
62 | seq_printf(s, "vdd:\t\t%u ", ios->vdd); |
63 | if ((1 << ios->vdd) & MMC_VDD_165_195) | |
64 | seq_printf(s, "(1.65 - 1.95 V)\n"); | |
65 | else if (ios->vdd < (ARRAY_SIZE(vdd_str) - 1) | |
66 | && vdd_str[ios->vdd] && vdd_str[ios->vdd + 1]) | |
67 | seq_printf(s, "(%s ~ %s V)\n", vdd_str[ios->vdd], | |
68 | vdd_str[ios->vdd + 1]); | |
69 | else | |
70 | seq_printf(s, "(invalid)\n"); | |
71 | ||
72 | switch (ios->bus_mode) { | |
73 | case MMC_BUSMODE_OPENDRAIN: | |
74 | str = "open drain"; | |
75 | break; | |
76 | case MMC_BUSMODE_PUSHPULL: | |
77 | str = "push-pull"; | |
78 | break; | |
79 | default: | |
80 | str = "invalid"; | |
81 | break; | |
82 | } | |
83 | seq_printf(s, "bus mode:\t%u (%s)\n", ios->bus_mode, str); | |
84 | ||
85 | switch (ios->chip_select) { | |
86 | case MMC_CS_DONTCARE: | |
87 | str = "don't care"; | |
88 | break; | |
89 | case MMC_CS_HIGH: | |
90 | str = "active high"; | |
91 | break; | |
92 | case MMC_CS_LOW: | |
93 | str = "active low"; | |
94 | break; | |
95 | default: | |
96 | str = "invalid"; | |
97 | break; | |
98 | } | |
99 | seq_printf(s, "chip select:\t%u (%s)\n", ios->chip_select, str); | |
100 | ||
101 | switch (ios->power_mode) { | |
102 | case MMC_POWER_OFF: | |
103 | str = "off"; | |
104 | break; | |
105 | case MMC_POWER_UP: | |
106 | str = "up"; | |
107 | break; | |
108 | case MMC_POWER_ON: | |
109 | str = "on"; | |
110 | break; | |
111 | default: | |
112 | str = "invalid"; | |
113 | break; | |
114 | } | |
115 | seq_printf(s, "power mode:\t%u (%s)\n", ios->power_mode, str); | |
116 | seq_printf(s, "bus width:\t%u (%u bits)\n", | |
117 | ios->bus_width, 1 << ios->bus_width); | |
118 | ||
119 | switch (ios->timing) { | |
120 | case MMC_TIMING_LEGACY: | |
121 | str = "legacy"; | |
122 | break; | |
123 | case MMC_TIMING_MMC_HS: | |
124 | str = "mmc high-speed"; | |
125 | break; | |
126 | case MMC_TIMING_SD_HS: | |
127 | str = "sd high-speed"; | |
128 | break; | |
cd8a3666 AL |
129 | case MMC_TIMING_UHS_SDR50: |
130 | str = "sd uhs SDR50"; | |
131 | break; | |
132 | case MMC_TIMING_UHS_SDR104: | |
133 | str = "sd uhs SDR104"; | |
134 | break; | |
135 | case MMC_TIMING_UHS_DDR50: | |
136 | str = "sd uhs DDR50"; | |
137 | break; | |
a4924c71 G |
138 | case MMC_TIMING_MMC_HS200: |
139 | str = "mmc high-speed SDR200"; | |
140 | break; | |
6fa3eb70 S |
141 | #ifdef CONFIG_EMMC_50_FEATURE |
142 | case MMC_TIMING_MMC_HS400: | |
143 | str = "mmc high-speed DDR200(HS400)"; | |
144 | break; | |
145 | #endif | |
6edd8ee6 HS |
146 | default: |
147 | str = "invalid"; | |
148 | break; | |
149 | } | |
150 | seq_printf(s, "timing spec:\t%u (%s)\n", ios->timing, str); | |
151 | ||
42cd95a0 JR |
152 | switch (ios->signal_voltage) { |
153 | case MMC_SIGNAL_VOLTAGE_330: | |
154 | str = "3.30 V"; | |
155 | break; | |
156 | case MMC_SIGNAL_VOLTAGE_180: | |
157 | str = "1.80 V"; | |
158 | break; | |
159 | case MMC_SIGNAL_VOLTAGE_120: | |
160 | str = "1.20 V"; | |
161 | break; | |
162 | default: | |
163 | str = "invalid"; | |
164 | break; | |
165 | } | |
166 | seq_printf(s, "signal voltage:\t%u (%s)\n", ios->chip_select, str); | |
167 | ||
6edd8ee6 HS |
168 | return 0; |
169 | } | |
170 | ||
171 | static int mmc_ios_open(struct inode *inode, struct file *file) | |
172 | { | |
173 | return single_open(file, mmc_ios_show, inode->i_private); | |
174 | } | |
175 | ||
176 | static const struct file_operations mmc_ios_fops = { | |
177 | .open = mmc_ios_open, | |
178 | .read = seq_read, | |
179 | .llseek = seq_lseek, | |
180 | .release = single_release, | |
181 | }; | |
182 | ||
703aae3d AS |
183 | static int mmc_clock_opt_get(void *data, u64 *val) |
184 | { | |
185 | struct mmc_host *host = data; | |
186 | ||
187 | *val = host->ios.clock; | |
188 | ||
189 | return 0; | |
190 | } | |
191 | ||
192 | static int mmc_clock_opt_set(void *data, u64 val) | |
193 | { | |
194 | struct mmc_host *host = data; | |
195 | ||
196 | /* We need this check due to input value is u64 */ | |
197 | if (val > host->f_max) | |
198 | return -EINVAL; | |
199 | ||
200 | mmc_claim_host(host); | |
201 | mmc_set_clock(host, (unsigned int) val); | |
202 | mmc_release_host(host); | |
203 | ||
204 | return 0; | |
205 | } | |
206 | ||
207 | DEFINE_SIMPLE_ATTRIBUTE(mmc_clock_fops, mmc_clock_opt_get, mmc_clock_opt_set, | |
208 | "%llu\n"); | |
209 | ||
6edd8ee6 HS |
210 | void mmc_add_host_debugfs(struct mmc_host *host) |
211 | { | |
212 | struct dentry *root; | |
213 | ||
214 | root = debugfs_create_dir(mmc_hostname(host), NULL); | |
215 | if (IS_ERR(root)) | |
216 | /* Don't complain -- debugfs just isn't enabled */ | |
217 | return; | |
218 | if (!root) | |
219 | /* Complain -- debugfs is enabled, but it failed to | |
220 | * create the directory. */ | |
221 | goto err_root; | |
222 | ||
223 | host->debugfs_root = root; | |
224 | ||
225 | if (!debugfs_create_file("ios", S_IRUSR, root, host, &mmc_ios_fops)) | |
703aae3d AS |
226 | goto err_node; |
227 | ||
228 | if (!debugfs_create_file("clock", S_IRUSR | S_IWUSR, root, host, | |
229 | &mmc_clock_fops)) | |
230 | goto err_node; | |
6edd8ee6 | 231 | |
04566831 LW |
232 | #ifdef CONFIG_MMC_CLKGATE |
233 | if (!debugfs_create_u32("clk_delay", (S_IRUSR | S_IWUSR), | |
234 | root, &host->clk_delay)) | |
235 | goto err_node; | |
1b676f70 PF |
236 | #endif |
237 | #ifdef CONFIG_FAIL_MMC_REQUEST | |
34f50508 PF |
238 | if (fail_request) |
239 | setup_fault_attr(&fail_default_attr, fail_request); | |
240 | host->fail_mmc_request = fail_default_attr; | |
1b676f70 PF |
241 | if (IS_ERR(fault_create_debugfs_attr("fail_mmc_request", |
242 | root, | |
243 | &host->fail_mmc_request))) | |
244 | goto err_node; | |
04566831 | 245 | #endif |
6edd8ee6 HS |
246 | return; |
247 | ||
703aae3d | 248 | err_node: |
6edd8ee6 HS |
249 | debugfs_remove_recursive(root); |
250 | host->debugfs_root = NULL; | |
251 | err_root: | |
252 | dev_err(&host->class_dev, "failed to initialize debugfs\n"); | |
253 | } | |
254 | ||
255 | void mmc_remove_host_debugfs(struct mmc_host *host) | |
256 | { | |
257 | debugfs_remove_recursive(host->debugfs_root); | |
258 | } | |
f4b7f927 HS |
259 | |
260 | static int mmc_dbg_card_status_get(void *data, u64 *val) | |
261 | { | |
262 | struct mmc_card *card = data; | |
263 | u32 status; | |
264 | int ret; | |
265 | ||
266 | mmc_claim_host(card->host); | |
267 | ||
268 | ret = mmc_send_status(data, &status); | |
269 | if (!ret) | |
270 | *val = status; | |
271 | ||
272 | mmc_release_host(card->host); | |
273 | ||
274 | return ret; | |
275 | } | |
276 | DEFINE_SIMPLE_ATTRIBUTE(mmc_dbg_card_status_fops, mmc_dbg_card_status_get, | |
277 | NULL, "%08llx\n"); | |
278 | ||
736bb6bb AH |
279 | #define EXT_CSD_STR_LEN 1025 |
280 | ||
281 | static int mmc_ext_csd_open(struct inode *inode, struct file *filp) | |
282 | { | |
283 | struct mmc_card *card = inode->i_private; | |
284 | char *buf; | |
285 | ssize_t n = 0; | |
286 | u8 *ext_csd; | |
287 | int err, i; | |
288 | ||
289 | buf = kmalloc(EXT_CSD_STR_LEN + 1, GFP_KERNEL); | |
290 | if (!buf) | |
291 | return -ENOMEM; | |
292 | ||
293 | ext_csd = kmalloc(512, GFP_KERNEL); | |
294 | if (!ext_csd) { | |
295 | err = -ENOMEM; | |
296 | goto out_free; | |
297 | } | |
298 | ||
299 | mmc_claim_host(card->host); | |
300 | err = mmc_send_ext_csd(card, ext_csd); | |
301 | mmc_release_host(card->host); | |
302 | if (err) | |
303 | goto out_free; | |
304 | ||
6780162c | 305 | for (i = 0; i < 512; i++) |
736bb6bb AH |
306 | n += sprintf(buf + n, "%02x", ext_csd[i]); |
307 | n += sprintf(buf + n, "\n"); | |
308 | BUG_ON(n != EXT_CSD_STR_LEN); | |
309 | ||
310 | filp->private_data = buf; | |
311 | kfree(ext_csd); | |
312 | return 0; | |
313 | ||
314 | out_free: | |
315 | kfree(buf); | |
316 | kfree(ext_csd); | |
317 | return err; | |
318 | } | |
319 | ||
320 | static ssize_t mmc_ext_csd_read(struct file *filp, char __user *ubuf, | |
321 | size_t cnt, loff_t *ppos) | |
322 | { | |
323 | char *buf = filp->private_data; | |
324 | ||
325 | return simple_read_from_buffer(ubuf, cnt, ppos, | |
326 | buf, EXT_CSD_STR_LEN); | |
327 | } | |
328 | ||
329 | static int mmc_ext_csd_release(struct inode *inode, struct file *file) | |
330 | { | |
331 | kfree(file->private_data); | |
332 | return 0; | |
333 | } | |
334 | ||
828c0950 | 335 | static const struct file_operations mmc_dbg_ext_csd_fops = { |
736bb6bb AH |
336 | .open = mmc_ext_csd_open, |
337 | .read = mmc_ext_csd_read, | |
338 | .release = mmc_ext_csd_release, | |
6038f373 | 339 | .llseek = default_llseek, |
736bb6bb AH |
340 | }; |
341 | ||
f4b7f927 HS |
342 | void mmc_add_card_debugfs(struct mmc_card *card) |
343 | { | |
344 | struct mmc_host *host = card->host; | |
345 | struct dentry *root; | |
346 | ||
347 | if (!host->debugfs_root) | |
348 | return; | |
349 | ||
350 | root = debugfs_create_dir(mmc_card_id(card), host->debugfs_root); | |
351 | if (IS_ERR(root)) | |
352 | /* Don't complain -- debugfs just isn't enabled */ | |
353 | return; | |
354 | if (!root) | |
355 | /* Complain -- debugfs is enabled, but it failed to | |
356 | * create the directory. */ | |
357 | goto err; | |
358 | ||
359 | card->debugfs_root = root; | |
360 | ||
361 | if (!debugfs_create_x32("state", S_IRUSR, root, &card->state)) | |
362 | goto err; | |
363 | ||
364 | if (mmc_card_mmc(card) || mmc_card_sd(card)) | |
365 | if (!debugfs_create_file("status", S_IRUSR, root, card, | |
366 | &mmc_dbg_card_status_fops)) | |
367 | goto err; | |
368 | ||
736bb6bb AH |
369 | if (mmc_card_mmc(card)) |
370 | if (!debugfs_create_file("ext_csd", S_IRUSR, root, card, | |
371 | &mmc_dbg_ext_csd_fops)) | |
372 | goto err; | |
373 | ||
f4b7f927 HS |
374 | return; |
375 | ||
376 | err: | |
377 | debugfs_remove_recursive(root); | |
378 | card->debugfs_root = NULL; | |
379 | dev_err(&card->dev, "failed to initialize debugfs\n"); | |
380 | } | |
381 | ||
382 | void mmc_remove_card_debugfs(struct mmc_card *card) | |
383 | { | |
384 | debugfs_remove_recursive(card->debugfs_root); | |
385 | } |