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_SDR12: 130 str = "sd uhs SDR12"; 131 break; 132 case MMC_TIMING_UHS_SDR25: 133 str = "sd uhs SDR25"; 134 break; 135 case MMC_TIMING_UHS_SDR50: 136 str = "sd uhs SDR50"; 137 break; 138 case MMC_TIMING_UHS_SDR104: 139 str = "sd uhs SDR104"; 140 break; 141 case MMC_TIMING_UHS_DDR50: 142 str = "sd uhs DDR50"; 143 break; 144 case MMC_TIMING_MMC_DDR52: 145 str = "mmc DDR52"; 146 break; 147 case MMC_TIMING_MMC_HS200: 148 str = "mmc HS200"; 149 break; 150 case MMC_TIMING_MMC_HS400: 151 str = "mmc HS400"; 152 break; 153 default: 154 str = "invalid"; 155 break; 156 } 157 seq_printf(s, "timing spec:\t%u (%s)\n", ios->timing, str); 158 159 switch (ios->signal_voltage) { 160 case MMC_SIGNAL_VOLTAGE_330: 161 str = "3.30 V"; 162 break; 163 case MMC_SIGNAL_VOLTAGE_180: 164 str = "1.80 V"; 165 break; 166 case MMC_SIGNAL_VOLTAGE_120: 167 str = "1.20 V"; 168 break; 169 default: 170 str = "invalid"; 171 break; 172 } 173 seq_printf(s, "signal voltage:\t%u (%s)\n", ios->signal_voltage, str); 174 175 switch (ios->drv_type) { 176 case MMC_SET_DRIVER_TYPE_A: 177 str = "driver type A"; 178 break; 179 case MMC_SET_DRIVER_TYPE_B: 180 str = "driver type B"; 181 break; 182 case MMC_SET_DRIVER_TYPE_C: 183 str = "driver type C"; 184 break; 185 case MMC_SET_DRIVER_TYPE_D: 186 str = "driver type D"; 187 break; 188 default: 189 str = "invalid"; 190 break; 191 } 192 seq_printf(s, "driver type:\t%u (%s)\n", ios->drv_type, str); 193 194 return 0; 195 } 196 197 static int mmc_ios_open(struct inode *inode, struct file *file) 198 { 199 return single_open(file, mmc_ios_show, inode->i_private); 200 } 201 202 static const struct file_operations mmc_ios_fops = { 203 .open = mmc_ios_open, 204 .read = seq_read, 205 .llseek = seq_lseek, 206 .release = single_release, 207 }; 208 209 static int mmc_clock_opt_get(void *data, u64 *val) 210 { 211 struct mmc_host *host = data; 212 213 *val = host->ios.clock; 214 215 return 0; 216 } 217 218 static int mmc_clock_opt_set(void *data, u64 val) 219 { 220 struct mmc_host *host = data; 221 222 /* We need this check due to input value is u64 */ 223 if (val > host->f_max) 224 return -EINVAL; 225 226 mmc_claim_host(host); 227 mmc_set_clock(host, (unsigned int) val); 228 mmc_release_host(host); 229 230 return 0; 231 } 232 233 DEFINE_SIMPLE_ATTRIBUTE(mmc_clock_fops, mmc_clock_opt_get, mmc_clock_opt_set, 234 "%llu\n"); 235 236 void mmc_add_host_debugfs(struct mmc_host *host) 237 { 238 struct dentry *root; 239 240 root = debugfs_create_dir(mmc_hostname(host), NULL); 241 if (IS_ERR(root)) 242 /* Don't complain -- debugfs just isn't enabled */ 243 return; 244 if (!root) 245 /* Complain -- debugfs is enabled, but it failed to 246 * create the directory. */ 247 goto err_root; 248 249 host->debugfs_root = root; 250 251 if (!debugfs_create_file("ios", S_IRUSR, root, host, &mmc_ios_fops)) 252 goto err_node; 253 254 if (!debugfs_create_file("clock", S_IRUSR | S_IWUSR, root, host, 255 &mmc_clock_fops)) 256 goto err_node; 257 258 #ifdef CONFIG_FAIL_MMC_REQUEST 259 if (fail_request) 260 setup_fault_attr(&fail_default_attr, fail_request); 261 host->fail_mmc_request = fail_default_attr; 262 if (IS_ERR(fault_create_debugfs_attr("fail_mmc_request", 263 root, 264 &host->fail_mmc_request))) 265 goto err_node; 266 #endif 267 return; 268 269 err_node: 270 debugfs_remove_recursive(root); 271 host->debugfs_root = NULL; 272 err_root: 273 dev_err(&host->class_dev, "failed to initialize debugfs\n"); 274 } 275 276 void mmc_remove_host_debugfs(struct mmc_host *host) 277 { 278 debugfs_remove_recursive(host->debugfs_root); 279 } 280 281 static int mmc_dbg_card_status_get(void *data, u64 *val) 282 { 283 struct mmc_card *card = data; 284 u32 status; 285 int ret; 286 287 mmc_get_card(card); 288 289 ret = mmc_send_status(data, &status); 290 if (!ret) 291 *val = status; 292 293 mmc_put_card(card); 294 295 return ret; 296 } 297 DEFINE_SIMPLE_ATTRIBUTE(mmc_dbg_card_status_fops, mmc_dbg_card_status_get, 298 NULL, "%08llx\n"); 299 300 #define EXT_CSD_STR_LEN 1025 301 302 static int mmc_ext_csd_open(struct inode *inode, struct file *filp) 303 { 304 struct mmc_card *card = inode->i_private; 305 char *buf; 306 ssize_t n = 0; 307 u8 *ext_csd; 308 int err, i; 309 310 buf = kmalloc(EXT_CSD_STR_LEN + 1, GFP_KERNEL); 311 if (!buf) 312 return -ENOMEM; 313 314 mmc_get_card(card); 315 err = mmc_get_ext_csd(card, &ext_csd); 316 mmc_put_card(card); 317 if (err) 318 goto out_free; 319 320 for (i = 0; i < 512; i++) 321 n += sprintf(buf + n, "%02x", ext_csd[i]); 322 n += sprintf(buf + n, "\n"); 323 BUG_ON(n != EXT_CSD_STR_LEN); 324 325 filp->private_data = buf; 326 kfree(ext_csd); 327 return 0; 328 329 out_free: 330 kfree(buf); 331 return err; 332 } 333 334 static ssize_t mmc_ext_csd_read(struct file *filp, char __user *ubuf, 335 size_t cnt, loff_t *ppos) 336 { 337 char *buf = filp->private_data; 338 339 return simple_read_from_buffer(ubuf, cnt, ppos, 340 buf, EXT_CSD_STR_LEN); 341 } 342 343 static int mmc_ext_csd_release(struct inode *inode, struct file *file) 344 { 345 kfree(file->private_data); 346 return 0; 347 } 348 349 static const struct file_operations mmc_dbg_ext_csd_fops = { 350 .open = mmc_ext_csd_open, 351 .read = mmc_ext_csd_read, 352 .release = mmc_ext_csd_release, 353 .llseek = default_llseek, 354 }; 355 356 void mmc_add_card_debugfs(struct mmc_card *card) 357 { 358 struct mmc_host *host = card->host; 359 struct dentry *root; 360 361 if (!host->debugfs_root) 362 return; 363 364 root = debugfs_create_dir(mmc_card_id(card), host->debugfs_root); 365 if (IS_ERR(root)) 366 /* Don't complain -- debugfs just isn't enabled */ 367 return; 368 if (!root) 369 /* Complain -- debugfs is enabled, but it failed to 370 * create the directory. */ 371 goto err; 372 373 card->debugfs_root = root; 374 375 if (!debugfs_create_x32("state", S_IRUSR, root, &card->state)) 376 goto err; 377 378 if (mmc_card_mmc(card) || mmc_card_sd(card)) 379 if (!debugfs_create_file("status", S_IRUSR, root, card, 380 &mmc_dbg_card_status_fops)) 381 goto err; 382 383 if (mmc_card_mmc(card)) 384 if (!debugfs_create_file("ext_csd", S_IRUSR, root, card, 385 &mmc_dbg_ext_csd_fops)) 386 goto err; 387 388 return; 389 390 err: 391 debugfs_remove_recursive(root); 392 card->debugfs_root = NULL; 393 dev_err(&card->dev, "failed to initialize debugfs\n"); 394 } 395 396 void mmc_remove_card_debugfs(struct mmc_card *card) 397 { 398 debugfs_remove_recursive(card->debugfs_root); 399 } 400