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 }