Merge branch 'linus' into irq/threaded
[linux-2.6] / 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/debugfs.h>
11 #include <linux/fs.h>
12 #include <linux/seq_file.h>
13 #include <linux/stat.h>
14
15 #include <linux/mmc/card.h>
16 #include <linux/mmc/host.h>
17
18 #include "core.h"
19 #include "mmc_ops.h"
20
21 /* The debugfs functions are optimized away when CONFIG_DEBUG_FS isn't set. */
22 static int mmc_ios_show(struct seq_file *s, void *data)
23 {
24         static const char *vdd_str[] = {
25                 [8]     = "2.0",
26                 [9]     = "2.1",
27                 [10]    = "2.2",
28                 [11]    = "2.3",
29                 [12]    = "2.4",
30                 [13]    = "2.5",
31                 [14]    = "2.6",
32                 [15]    = "2.7",
33                 [16]    = "2.8",
34                 [17]    = "2.9",
35                 [18]    = "3.0",
36                 [19]    = "3.1",
37                 [20]    = "3.2",
38                 [21]    = "3.3",
39                 [22]    = "3.4",
40                 [23]    = "3.5",
41                 [24]    = "3.6",
42         };
43         struct mmc_host *host = s->private;
44         struct mmc_ios  *ios = &host->ios;
45         const char *str;
46
47         seq_printf(s, "clock:\t\t%u Hz\n", ios->clock);
48         seq_printf(s, "vdd:\t\t%u ", ios->vdd);
49         if ((1 << ios->vdd) & MMC_VDD_165_195)
50                 seq_printf(s, "(1.65 - 1.95 V)\n");
51         else if (ios->vdd < (ARRAY_SIZE(vdd_str) - 1)
52                         && vdd_str[ios->vdd] && vdd_str[ios->vdd + 1])
53                 seq_printf(s, "(%s ~ %s V)\n", vdd_str[ios->vdd],
54                                 vdd_str[ios->vdd + 1]);
55         else
56                 seq_printf(s, "(invalid)\n");
57
58         switch (ios->bus_mode) {
59         case MMC_BUSMODE_OPENDRAIN:
60                 str = "open drain";
61                 break;
62         case MMC_BUSMODE_PUSHPULL:
63                 str = "push-pull";
64                 break;
65         default:
66                 str = "invalid";
67                 break;
68         }
69         seq_printf(s, "bus mode:\t%u (%s)\n", ios->bus_mode, str);
70
71         switch (ios->chip_select) {
72         case MMC_CS_DONTCARE:
73                 str = "don't care";
74                 break;
75         case MMC_CS_HIGH:
76                 str = "active high";
77                 break;
78         case MMC_CS_LOW:
79                 str = "active low";
80                 break;
81         default:
82                 str = "invalid";
83                 break;
84         }
85         seq_printf(s, "chip select:\t%u (%s)\n", ios->chip_select, str);
86
87         switch (ios->power_mode) {
88         case MMC_POWER_OFF:
89                 str = "off";
90                 break;
91         case MMC_POWER_UP:
92                 str = "up";
93                 break;
94         case MMC_POWER_ON:
95                 str = "on";
96                 break;
97         default:
98                 str = "invalid";
99                 break;
100         }
101         seq_printf(s, "power mode:\t%u (%s)\n", ios->power_mode, str);
102         seq_printf(s, "bus width:\t%u (%u bits)\n",
103                         ios->bus_width, 1 << ios->bus_width);
104
105         switch (ios->timing) {
106         case MMC_TIMING_LEGACY:
107                 str = "legacy";
108                 break;
109         case MMC_TIMING_MMC_HS:
110                 str = "mmc high-speed";
111                 break;
112         case MMC_TIMING_SD_HS:
113                 str = "sd high-speed";
114                 break;
115         default:
116                 str = "invalid";
117                 break;
118         }
119         seq_printf(s, "timing spec:\t%u (%s)\n", ios->timing, str);
120
121         return 0;
122 }
123
124 static int mmc_ios_open(struct inode *inode, struct file *file)
125 {
126         return single_open(file, mmc_ios_show, inode->i_private);
127 }
128
129 static const struct file_operations mmc_ios_fops = {
130         .open           = mmc_ios_open,
131         .read           = seq_read,
132         .llseek         = seq_lseek,
133         .release        = single_release,
134 };
135
136 void mmc_add_host_debugfs(struct mmc_host *host)
137 {
138         struct dentry *root;
139
140         root = debugfs_create_dir(mmc_hostname(host), NULL);
141         if (IS_ERR(root))
142                 /* Don't complain -- debugfs just isn't enabled */
143                 return;
144         if (!root)
145                 /* Complain -- debugfs is enabled, but it failed to
146                  * create the directory. */
147                 goto err_root;
148
149         host->debugfs_root = root;
150
151         if (!debugfs_create_file("ios", S_IRUSR, root, host, &mmc_ios_fops))
152                 goto err_ios;
153
154         return;
155
156 err_ios:
157         debugfs_remove_recursive(root);
158         host->debugfs_root = NULL;
159 err_root:
160         dev_err(&host->class_dev, "failed to initialize debugfs\n");
161 }
162
163 void mmc_remove_host_debugfs(struct mmc_host *host)
164 {
165         debugfs_remove_recursive(host->debugfs_root);
166 }
167
168 static int mmc_dbg_card_status_get(void *data, u64 *val)
169 {
170         struct mmc_card *card = data;
171         u32             status;
172         int             ret;
173
174         mmc_claim_host(card->host);
175
176         ret = mmc_send_status(data, &status);
177         if (!ret)
178                 *val = status;
179
180         mmc_release_host(card->host);
181
182         return ret;
183 }
184 DEFINE_SIMPLE_ATTRIBUTE(mmc_dbg_card_status_fops, mmc_dbg_card_status_get,
185                 NULL, "%08llx\n");
186
187 #define EXT_CSD_STR_LEN 1025
188
189 static int mmc_ext_csd_open(struct inode *inode, struct file *filp)
190 {
191         struct mmc_card *card = inode->i_private;
192         char *buf;
193         ssize_t n = 0;
194         u8 *ext_csd;
195         int err, i;
196
197         buf = kmalloc(EXT_CSD_STR_LEN + 1, GFP_KERNEL);
198         if (!buf)
199                 return -ENOMEM;
200
201         ext_csd = kmalloc(512, GFP_KERNEL);
202         if (!ext_csd) {
203                 err = -ENOMEM;
204                 goto out_free;
205         }
206
207         mmc_claim_host(card->host);
208         err = mmc_send_ext_csd(card, ext_csd);
209         mmc_release_host(card->host);
210         if (err)
211                 goto out_free;
212
213         for (i = 511; i >= 0; i--)
214                 n += sprintf(buf + n, "%02x", ext_csd[i]);
215         n += sprintf(buf + n, "\n");
216         BUG_ON(n != EXT_CSD_STR_LEN);
217
218         filp->private_data = buf;
219         kfree(ext_csd);
220         return 0;
221
222 out_free:
223         kfree(buf);
224         kfree(ext_csd);
225         return err;
226 }
227
228 static ssize_t mmc_ext_csd_read(struct file *filp, char __user *ubuf,
229                                 size_t cnt, loff_t *ppos)
230 {
231         char *buf = filp->private_data;
232
233         return simple_read_from_buffer(ubuf, cnt, ppos,
234                                        buf, EXT_CSD_STR_LEN);
235 }
236
237 static int mmc_ext_csd_release(struct inode *inode, struct file *file)
238 {
239         kfree(file->private_data);
240         return 0;
241 }
242
243 static struct file_operations mmc_dbg_ext_csd_fops = {
244         .open           = mmc_ext_csd_open,
245         .read           = mmc_ext_csd_read,
246         .release        = mmc_ext_csd_release,
247 };
248
249 void mmc_add_card_debugfs(struct mmc_card *card)
250 {
251         struct mmc_host *host = card->host;
252         struct dentry   *root;
253
254         if (!host->debugfs_root)
255                 return;
256
257         root = debugfs_create_dir(mmc_card_id(card), host->debugfs_root);
258         if (IS_ERR(root))
259                 /* Don't complain -- debugfs just isn't enabled */
260                 return;
261         if (!root)
262                 /* Complain -- debugfs is enabled, but it failed to
263                  * create the directory. */
264                 goto err;
265
266         card->debugfs_root = root;
267
268         if (!debugfs_create_x32("state", S_IRUSR, root, &card->state))
269                 goto err;
270
271         if (mmc_card_mmc(card) || mmc_card_sd(card))
272                 if (!debugfs_create_file("status", S_IRUSR, root, card,
273                                         &mmc_dbg_card_status_fops))
274                         goto err;
275
276         if (mmc_card_mmc(card))
277                 if (!debugfs_create_file("ext_csd", S_IRUSR, root, card,
278                                         &mmc_dbg_ext_csd_fops))
279                         goto err;
280
281         return;
282
283 err:
284         debugfs_remove_recursive(root);
285         card->debugfs_root = NULL;
286         dev_err(&card->dev, "failed to initialize debugfs\n");
287 }
288
289 void mmc_remove_card_debugfs(struct mmc_card *card)
290 {
291         debugfs_remove_recursive(card->debugfs_root);
292 }