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