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