mmc: core: HS200 mode support for eMMC 4.5
[~shefty/rdma-dev.git] / drivers / mmc / core / debugfs.c
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  */
10 #include <linux/moduleparam.h>
11 #include <linux/export.h>
12 #include <linux/debugfs.h>
13 #include <linux/fs.h>
14 #include <linux/seq_file.h>
15 #include <linux/slab.h>
16 #include <linux/stat.h>
17 #include <linux/fault-inject.h>
18
19 #include <linux/mmc/card.h>
20 #include <linux/mmc/host.h>
21
22 #include "core.h"
23 #include "mmc_ops.h"
24
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
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);
60         if (host->actual_clock)
61                 seq_printf(s, "actual clock:\t%u Hz\n", host->actual_clock);
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;
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;
138         case MMC_TIMING_MMC_HS200:
139                 str = "mmc high-speed SDR200";
140                 break;
141         default:
142                 str = "invalid";
143                 break;
144         }
145         seq_printf(s, "timing spec:\t%u (%s)\n", ios->timing, str);
146
147         return 0;
148 }
149
150 static int mmc_ios_open(struct inode *inode, struct file *file)
151 {
152         return single_open(file, mmc_ios_show, inode->i_private);
153 }
154
155 static const struct file_operations mmc_ios_fops = {
156         .open           = mmc_ios_open,
157         .read           = seq_read,
158         .llseek         = seq_lseek,
159         .release        = single_release,
160 };
161
162 static int mmc_clock_opt_get(void *data, u64 *val)
163 {
164         struct mmc_host *host = data;
165
166         *val = host->ios.clock;
167
168         return 0;
169 }
170
171 static int mmc_clock_opt_set(void *data, u64 val)
172 {
173         struct mmc_host *host = data;
174
175         /* We need this check due to input value is u64 */
176         if (val > host->f_max)
177                 return -EINVAL;
178
179         mmc_claim_host(host);
180         mmc_set_clock(host, (unsigned int) val);
181         mmc_release_host(host);
182
183         return 0;
184 }
185
186 DEFINE_SIMPLE_ATTRIBUTE(mmc_clock_fops, mmc_clock_opt_get, mmc_clock_opt_set,
187         "%llu\n");
188
189 void mmc_add_host_debugfs(struct mmc_host *host)
190 {
191         struct dentry *root;
192
193         root = debugfs_create_dir(mmc_hostname(host), NULL);
194         if (IS_ERR(root))
195                 /* Don't complain -- debugfs just isn't enabled */
196                 return;
197         if (!root)
198                 /* Complain -- debugfs is enabled, but it failed to
199                  * create the directory. */
200                 goto err_root;
201
202         host->debugfs_root = root;
203
204         if (!debugfs_create_file("ios", S_IRUSR, root, host, &mmc_ios_fops))
205                 goto err_node;
206
207         if (!debugfs_create_file("clock", S_IRUSR | S_IWUSR, root, host,
208                         &mmc_clock_fops))
209                 goto err_node;
210
211 #ifdef CONFIG_MMC_CLKGATE
212         if (!debugfs_create_u32("clk_delay", (S_IRUSR | S_IWUSR),
213                                 root, &host->clk_delay))
214                 goto err_node;
215 #endif
216 #ifdef CONFIG_FAIL_MMC_REQUEST
217         if (fail_request)
218                 setup_fault_attr(&fail_default_attr, fail_request);
219         host->fail_mmc_request = fail_default_attr;
220         if (IS_ERR(fault_create_debugfs_attr("fail_mmc_request",
221                                              root,
222                                              &host->fail_mmc_request)))
223                 goto err_node;
224 #endif
225         return;
226
227 err_node:
228         debugfs_remove_recursive(root);
229         host->debugfs_root = NULL;
230 err_root:
231         dev_err(&host->class_dev, "failed to initialize debugfs\n");
232 }
233
234 void mmc_remove_host_debugfs(struct mmc_host *host)
235 {
236         debugfs_remove_recursive(host->debugfs_root);
237 }
238
239 static int mmc_dbg_card_status_get(void *data, u64 *val)
240 {
241         struct mmc_card *card = data;
242         u32             status;
243         int             ret;
244
245         mmc_claim_host(card->host);
246
247         ret = mmc_send_status(data, &status);
248         if (!ret)
249                 *val = status;
250
251         mmc_release_host(card->host);
252
253         return ret;
254 }
255 DEFINE_SIMPLE_ATTRIBUTE(mmc_dbg_card_status_fops, mmc_dbg_card_status_get,
256                 NULL, "%08llx\n");
257
258 #define EXT_CSD_STR_LEN 1025
259
260 static int mmc_ext_csd_open(struct inode *inode, struct file *filp)
261 {
262         struct mmc_card *card = inode->i_private;
263         char *buf;
264         ssize_t n = 0;
265         u8 *ext_csd;
266         int err, i;
267
268         buf = kmalloc(EXT_CSD_STR_LEN + 1, GFP_KERNEL);
269         if (!buf)
270                 return -ENOMEM;
271
272         ext_csd = kmalloc(512, GFP_KERNEL);
273         if (!ext_csd) {
274                 err = -ENOMEM;
275                 goto out_free;
276         }
277
278         mmc_claim_host(card->host);
279         err = mmc_send_ext_csd(card, ext_csd);
280         mmc_release_host(card->host);
281         if (err)
282                 goto out_free;
283
284         for (i = 511; i >= 0; i--)
285                 n += sprintf(buf + n, "%02x", ext_csd[i]);
286         n += sprintf(buf + n, "\n");
287         BUG_ON(n != EXT_CSD_STR_LEN);
288
289         filp->private_data = buf;
290         kfree(ext_csd);
291         return 0;
292
293 out_free:
294         kfree(buf);
295         kfree(ext_csd);
296         return err;
297 }
298
299 static ssize_t mmc_ext_csd_read(struct file *filp, char __user *ubuf,
300                                 size_t cnt, loff_t *ppos)
301 {
302         char *buf = filp->private_data;
303
304         return simple_read_from_buffer(ubuf, cnt, ppos,
305                                        buf, EXT_CSD_STR_LEN);
306 }
307
308 static int mmc_ext_csd_release(struct inode *inode, struct file *file)
309 {
310         kfree(file->private_data);
311         return 0;
312 }
313
314 static const struct file_operations mmc_dbg_ext_csd_fops = {
315         .open           = mmc_ext_csd_open,
316         .read           = mmc_ext_csd_read,
317         .release        = mmc_ext_csd_release,
318         .llseek         = default_llseek,
319 };
320
321 void mmc_add_card_debugfs(struct mmc_card *card)
322 {
323         struct mmc_host *host = card->host;
324         struct dentry   *root;
325
326         if (!host->debugfs_root)
327                 return;
328
329         root = debugfs_create_dir(mmc_card_id(card), host->debugfs_root);
330         if (IS_ERR(root))
331                 /* Don't complain -- debugfs just isn't enabled */
332                 return;
333         if (!root)
334                 /* Complain -- debugfs is enabled, but it failed to
335                  * create the directory. */
336                 goto err;
337
338         card->debugfs_root = root;
339
340         if (!debugfs_create_x32("state", S_IRUSR, root, &card->state))
341                 goto err;
342
343         if (mmc_card_mmc(card) || mmc_card_sd(card))
344                 if (!debugfs_create_file("status", S_IRUSR, root, card,
345                                         &mmc_dbg_card_status_fops))
346                         goto err;
347
348         if (mmc_card_mmc(card))
349                 if (!debugfs_create_file("ext_csd", S_IRUSR, root, card,
350                                         &mmc_dbg_ext_csd_fops))
351                         goto err;
352
353         return;
354
355 err:
356         debugfs_remove_recursive(root);
357         card->debugfs_root = NULL;
358         dev_err(&card->dev, "failed to initialize debugfs\n");
359 }
360
361 void mmc_remove_card_debugfs(struct mmc_card *card)
362 {
363         debugfs_remove_recursive(card->debugfs_root);
364 }