static int __init lustre_init(void) { struct lnet_process_id lnet_id; struct timespec64 ts; int i, rc, seed[2]; BUILD_BUG_ON(sizeof(LUSTRE_VOLATILE_HDR) != LUSTRE_VOLATILE_HDR_LEN + 1); /* print an address of _any_ initialized kernel symbol from this * module, to allow debugging with gdb that doesn't support data * symbols from modules. */ CDEBUG(D_INFO, "Lustre client module (%p).\n", &lustre_super_operations); rc = -ENOMEM; ll_inode_cachep = kmem_cache_create("lustre_inode_cache", sizeof(struct ll_inode_info), 0, SLAB_HWCACHE_ALIGN | SLAB_ACCOUNT, NULL); if (!ll_inode_cachep) goto out_cache; ll_file_data_slab = kmem_cache_create("ll_file_data", sizeof(struct ll_file_data), 0, SLAB_HWCACHE_ALIGN, NULL); if (!ll_file_data_slab) goto out_cache; llite_root = debugfs_create_dir("llite", debugfs_lustre_root); if (IS_ERR_OR_NULL(llite_root)) { rc = llite_root ? PTR_ERR(llite_root) : -ENOMEM; llite_root = NULL; goto out_cache; } llite_kset = kset_create_and_add("llite", NULL, lustre_kobj); if (!llite_kset) { rc = -ENOMEM; goto out_debugfs; } cfs_get_random_bytes(seed, sizeof(seed)); /* Nodes with small feet have little entropy. The NID for this * node gives the most entropy in the low bits */ for (i = 0;; i++) { if (LNetGetId(i, &lnet_id) == -ENOENT) break; if (LNET_NETTYP(LNET_NIDNET(lnet_id.nid)) != LOLND) seed[0] ^= LNET_NIDADDR(lnet_id.nid); } ktime_get_ts64(&ts); cfs_srand(ts.tv_sec ^ seed[0], ts.tv_nsec ^ seed[1]); rc = vvp_global_init(); if (rc != 0) goto out_sysfs; cl_inode_fini_env = cl_env_alloc(&cl_inode_fini_refcheck, LCT_REMEMBER | LCT_NOREF); if (IS_ERR(cl_inode_fini_env)) { rc = PTR_ERR(cl_inode_fini_env); goto out_vvp; } cl_inode_fini_env->le_ctx.lc_cookie = 0x4; rc = ll_xattr_init(); if (rc != 0) goto out_inode_fini_env; lustre_register_client_fill_super(ll_fill_super); lustre_register_kill_super_cb(ll_kill_super); lustre_register_client_process_config(ll_process_config); return 0; out_inode_fini_env: cl_env_put(cl_inode_fini_env, &cl_inode_fini_refcheck); out_vvp: vvp_global_fini(); out_sysfs: kset_unregister(llite_kset); out_debugfs: debugfs_remove(llite_root); out_cache: kmem_cache_destroy(ll_inode_cachep); kmem_cache_destroy(ll_file_data_slab); return rc; }
static void bdi_debug_init(void) { bdi_debug_root = debugfs_create_dir("bdi", NULL); }
static int microblaze_debugfs_init(void) { of_debugfs_root = debugfs_create_dir("microblaze", NULL); return of_debugfs_root == NULL; }
void netfront_accel_debugfs_init(void) { #if defined(CONFIG_DEBUG_FS) sfc_debugfs_root = debugfs_create_dir(frontend_name, NULL); #endif }
static int __init snddev_icodec_init(void) { s32 rc; struct snddev_icodec_drv_state *icodec_drv = &snddev_icodec_drv; rc = platform_driver_register(&snddev_icodec_driver); if (IS_ERR_VALUE(rc)) goto error_platform_driver; icodec_drv->rx_mclk = clk_get(NULL, "mi2s_codec_rx_m_clk"); if (IS_ERR(icodec_drv->rx_mclk)) goto error_rx_mclk; icodec_drv->rx_sclk = clk_get(NULL, "mi2s_codec_rx_s_clk"); if (IS_ERR(icodec_drv->rx_sclk)) goto error_rx_sclk; icodec_drv->tx_mclk = clk_get(NULL, "mi2s_codec_tx_m_clk"); if (IS_ERR(icodec_drv->tx_mclk)) goto error_tx_mclk; icodec_drv->tx_sclk = clk_get(NULL, "mi2s_codec_tx_s_clk"); if (IS_ERR(icodec_drv->tx_sclk)) goto error_tx_sclk; icodec_drv->lpa_codec_clk = clk_get(NULL, "lpa_codec_clk"); if (IS_ERR(icodec_drv->lpa_codec_clk)) goto error_lpa_codec_clk; icodec_drv->lpa_core_clk = clk_get(NULL, "lpa_core_clk"); if (IS_ERR(icodec_drv->lpa_core_clk)) goto error_lpa_core_clk; icodec_drv->lpa_p_clk = clk_get(NULL, "lpa_pclk"); if (IS_ERR(icodec_drv->lpa_p_clk)) goto error_lpa_p_clk; #ifdef CONFIG_DEBUG_FS debugfs_sdev_dent = debugfs_create_dir("snddev_icodec", 0); if (debugfs_sdev_dent) { debugfs_afelb = debugfs_create_file("afe_loopback", S_IFREG | S_IWUGO, debugfs_sdev_dent, (void *) "afe_loopback", &snddev_icodec_debug_fops); debugfs_adielb = debugfs_create_file("adie_loopback", S_IFREG | S_IWUGO, debugfs_sdev_dent, (void *) "adie_loopback", &snddev_icodec_debug_fops); } #endif mutex_init(&icodec_drv->rx_lock); mutex_init(&icodec_drv->tx_lock); icodec_drv->rx_active = 0; icodec_drv->tx_active = 0; icodec_drv->lpa = NULL; wake_lock_init(&icodec_drv->tx_idlelock, WAKE_LOCK_IDLE, "snddev_tx_idle"); wake_lock_init(&icodec_drv->rx_idlelock, WAKE_LOCK_IDLE, "snddev_rx_idle"); return 0; error_lpa_p_clk: clk_put(icodec_drv->lpa_core_clk); error_lpa_core_clk: clk_put(icodec_drv->lpa_codec_clk); error_lpa_codec_clk: clk_put(icodec_drv->tx_sclk); error_tx_sclk: clk_put(icodec_drv->tx_mclk); error_tx_mclk: clk_put(icodec_drv->rx_sclk); error_rx_sclk: clk_put(icodec_drv->rx_mclk); error_rx_mclk: platform_driver_unregister(&snddev_icodec_driver); error_platform_driver: MM_ERR("encounter error\n"); return -ENODEV; }
struct dentry *vidc_get_debugfs_root(void) { if (vidc_debugfs_root == NULL) vidc_debugfs_root = debugfs_create_dir("vidc", NULL); return vidc_debugfs_root; }
static int __devinit max17047_fuelgauge_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct max17047_fuelgauge_data *fg_data; int ret; u8 i2c_data[2]; int rawsoc, firstsoc; pr_info("%s: max17047 Fuel gauge Driver Loading\n", __func__); if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) return -EIO; fg_data = kzalloc(sizeof(struct max17047_fuelgauge_data), GFP_KERNEL); if (!fg_data) return -ENOMEM; fg_data->client = client; fg_data->pdata = client->dev.platform_data; i2c_set_clientdata(client, fg_data); mutex_init(&fg_data->irq_lock); wake_lock_init(&fg_data->update_wake_lock, WAKE_LOCK_SUSPEND, "fuel-update"); /* Initialize full_soc, set this before fisrt SOC reading */ fg_data->full_soc = FULL_SOC_DEFAULT; /* first full_soc update */ rawsoc = max17047_get_rawsoc(fg_data->client); if (rawsoc > FULL_SOC_DEFAULT) max17047_adjust_fullsoc(client); firstsoc = max17047_get_soc(client); pr_info("%s: rsoc=%d, fsoc=%d, soc=%d\n", __func__, rawsoc, fg_data->full_soc, firstsoc); if (fg_data->pdata->psy_name) fg_data->fuelgauge.name = fg_data->pdata->psy_name; else fg_data->fuelgauge.name = "max17047-fuelgauge"; fg_data->fuelgauge.type = POWER_SUPPLY_TYPE_BATTERY; fg_data->fuelgauge.properties = max17047_fuelgauge_props; fg_data->fuelgauge.num_properties = ARRAY_SIZE(max17047_fuelgauge_props); fg_data->fuelgauge.get_property = max17047_get_property; fg_data->fuelgauge.set_property = max17047_set_property; ret = power_supply_register(&client->dev, &fg_data->fuelgauge); if (ret) { pr_err("%s: failed power supply register\n", __func__); goto err_psy_reg_fg; } /* Initialize fuelgauge registers */ max17047_reg_init(fg_data); /* Initialize fuelgauge alert */ max17047_alert_init(fg_data); /* Request IRQ */ fg_data->irq = gpio_to_irq(fg_data->pdata->irq_gpio); ret = gpio_request(fg_data->pdata->irq_gpio, "fuelgauge-irq"); if (ret) { pr_err("%s: failed requesting gpio %d\n", __func__, fg_data->pdata->irq_gpio); goto err_irq; } gpio_direction_input(fg_data->pdata->irq_gpio); gpio_free(fg_data->pdata->irq_gpio); ret = request_threaded_irq(fg_data->irq, NULL, max17047_fuelgauge_isr, IRQF_TRIGGER_FALLING, "max17047-alert", fg_data); if (ret < 0) { pr_err("%s: fail to request max17047 irq: %d: %d\n", __func__, fg_data->irq, ret); goto err_irq; } ret = enable_irq_wake(fg_data->irq); if (ret < 0) { pr_err("%s: failed enable irq wake %d\n", __func__, fg_data->irq); goto err_enable_irq; } INIT_DELAYED_WORK_DEFERRABLE(&fg_data->update_work, max17047_update_work); #ifdef DEBUG_FUELGAUGE_POLLING INIT_DELAYED_WORK_DEFERRABLE(&fg_data->polling_work, max17047_polling_work); schedule_delayed_work(&fg_data->polling_work, 0); #else max17047_test_read(fg_data); #endif max17047_i2c_read(client, MAX17047_REG_VERSION, i2c_data); pr_info("max17047 fuelgauge(rev.%d%d) initialized.\n", i2c_data[0], i2c_data[1]); #if defined(CONFIG_TARGET_LOCALE_KOR) #ifdef CONFIG_DEBUG_FS fg_data->fg_debugfs_dir = debugfs_create_dir("fg_debug", NULL); if (fg_data->fg_debugfs_dir) { if (!debugfs_create_file("max17047_regs", 0644, fg_data->fg_debugfs_dir, fg_data, &max17047_debugfs_fops)) pr_err("%s : debugfs_create_file, error\n", __func__); if (!debugfs_create_file("default_data", 0644, fg_data->fg_debugfs_dir, fg_data, &max17047_debugfs_fops2)) pr_err("%s : debugfs_create_file2, error\n", __func__); } else pr_err("%s : debugfs_create_dir, error\n", __func__); #endif #endif return 0; err_enable_irq: free_irq(fg_data->irq, fg_data); err_irq: power_supply_unregister(&fg_data->fuelgauge); err_psy_reg_fg: wake_lock_destroy(&fg_data->update_wake_lock); mutex_destroy(&fg_data->irq_lock); kfree(fg_data); return ret; }
void mmc_add_card_debugfs(struct mmc_card *card) { struct mmc_host *host = card->host; struct dentry *root; if (!host->debugfs_root) return; root = debugfs_create_dir(mmc_card_id(card), host->debugfs_root); if (IS_ERR(root)) /* Don't complain -- debugfs just isn't enabled */ return; if (!root) /* Complain -- debugfs is enabled, but it failed to * create the directory. */ goto err; card->debugfs_root = root; if (!debugfs_create_x32("state", S_IRUSR, root, &card->state)) goto err; if (mmc_card_mmc(card) || mmc_card_sd(card)) if (!debugfs_create_file("status", S_IRUSR, root, card, &mmc_dbg_card_status_fops)) goto err; if (mmc_card_mmc(card)) { if (!debugfs_create_file("ext_csd", S_IRUSR, root, card, &mmc_dbg_ext_csd_fops)) goto err; if (!debugfs_create_file("eol_status", S_IRUSR, root, card, &mmc_dbg_ext_csd_eol_fops)) goto err; if (!debugfs_create_file("dhs_type_a", S_IRUSR, root, card, &mmc_dbg_ext_csd_life_time_type_a_fops)) goto err; if (!debugfs_create_file("dhs_type_b", S_IRUSR, root, card, &mmc_dbg_ext_csd_life_time_type_b_fops)) goto err; if (!debugfs_create_file("emmc_device_type", S_IRUSR, root, card, &mmc_dbg_ext_csd_device_type_fops)) goto err; if (!debugfs_create_file("firmware_version", S_IRUSR, root, card, &mmc_dbg_ext_csd_fw_v_fops)) goto err; if (!debugfs_create_file("bkops_status", S_IRUSR, root, card, &mmc_dbg_ext_csd_bkops_status_fops)) goto err; if (!debugfs_create_file("bkops_support", S_IRUSR, root, card, &mmc_dbg_ext_csd_bkops_support_fops)) goto err; if (!debugfs_create_file("poweron_notify", S_IRUSR, root, card, &mmc_dbg_ext_csd_pon_notify_fops)) goto err; if (!debugfs_create_file("hpi_support", S_IRUSR, root, card, &mmc_dbg_ext_csd_hpi_support_fops)) goto err; } if (mmc_card_sd(card)) if (!debugfs_create_file("speed_class", S_IROTH, root, card, &mmc_dbg_card_speed_class_fops)) goto err; return; err: debugfs_remove_recursive(root); card->debugfs_root = NULL; dev_err(&card->dev, "failed to initialize debugfs\n"); }
int i2400m_debugfs_add(struct i2400m *i2400m) { int result; struct device *dev = i2400m_dev(i2400m); struct dentry *dentry = i2400m->wimax_dev.debugfs_dentry; struct dentry *fd; dentry = debugfs_create_dir("i2400m", dentry); result = PTR_ERR(dentry); if (IS_ERR(dentry)) { if (result == -ENODEV) result = 0; /* No debugfs support */ goto error; } i2400m->debugfs_dentry = dentry; __debugfs_register("dl_", control, dentry); __debugfs_register("dl_", driver, dentry); __debugfs_register("dl_", debugfs, dentry); __debugfs_register("dl_", fw, dentry); __debugfs_register("dl_", netdev, dentry); __debugfs_register("dl_", rfkill, dentry); __debugfs_register("dl_", rx, dentry); __debugfs_register("dl_", tx, dentry); fd = debugfs_create_size_t("tx_in", 0400, dentry, &i2400m->tx_in); result = PTR_ERR(fd); if (IS_ERR(fd) && result != -ENODEV) { dev_err(dev, "Can't create debugfs entry " "tx_in: %d\n", result); goto error; } fd = debugfs_create_size_t("tx_out", 0400, dentry, &i2400m->tx_out); result = PTR_ERR(fd); if (IS_ERR(fd) && result != -ENODEV) { dev_err(dev, "Can't create debugfs entry " "tx_out: %d\n", result); goto error; } fd = debugfs_create_u32("state", 0600, dentry, &i2400m->state); result = PTR_ERR(fd); if (IS_ERR(fd) && result != -ENODEV) { dev_err(dev, "Can't create debugfs entry " "state: %d\n", result); goto error; } /* * Trace received messages from user space * * In order to tap the bidirectional message stream in the * 'msg' pipe, user space can read from the 'msg' pipe; * however, due to limitations in libnl, we can't know what * the different applications are sending down to the kernel. * * So we have this hack where the driver will echo any message * received on the msg pipe from user space [through a call to * wimax_dev->op_msg_from_user() into * i2400m_op_msg_from_user()] into the 'trace' pipe that this * driver creates. * * So then, reading from both the 'trace' and 'msg' pipes in * user space will provide a full dump of the traffic. * * Write 1 to activate, 0 to clear. * * It is not really very atomic, but it is also not too * critical. */ fd = debugfs_create_u8("trace_msg_from_user", 0600, dentry, &i2400m->trace_msg_from_user); result = PTR_ERR(fd); if (IS_ERR(fd) && result != -ENODEV) { dev_err(dev, "Can't create debugfs entry " "trace_msg_from_user: %d\n", result); goto error; } fd = debugfs_create_netdev_queue_stopped("netdev_queue_stopped", dentry, i2400m); result = PTR_ERR(fd); if (IS_ERR(fd) && result != -ENODEV) { dev_err(dev, "Can't create debugfs entry " "netdev_queue_stopped: %d\n", result); goto error; } fd = debugfs_create_file("rx_stats", 0600, dentry, i2400m, &i2400m_rx_stats_fops); result = PTR_ERR(fd); if (IS_ERR(fd) && result != -ENODEV) { dev_err(dev, "Can't create debugfs entry " "rx_stats: %d\n", result); goto error; } fd = debugfs_create_file("tx_stats", 0600, dentry, i2400m, &i2400m_tx_stats_fops); result = PTR_ERR(fd); if (IS_ERR(fd) && result != -ENODEV) { dev_err(dev, "Can't create debugfs entry " "tx_stats: %d\n", result); goto error; } fd = debugfs_create_i2400m_suspend("suspend", dentry, i2400m); result = PTR_ERR(fd); if (IS_ERR(fd) && result != -ENODEV) { dev_err(dev, "Can't create debugfs entry suspend: %d\n", result); goto error; } fd = debugfs_create_i2400m_reset("reset", dentry, i2400m); result = PTR_ERR(fd); if (IS_ERR(fd) && result != -ENODEV) { dev_err(dev, "Can't create debugfs entry reset: %d\n", result); goto error; } result = 0; error: return result; }
void b43legacy_debugfs_add_device(struct b43legacy_wldev *dev) { struct b43legacy_dfsentry *e; struct b43legacy_txstatus_log *log; char devdir[16]; B43legacy_WARN_ON(!dev); e = kzalloc(sizeof(*e), GFP_KERNEL); if (!e) { b43legacyerr(dev->wl, "debugfs: add device OOM\n"); return; } e->dev = dev; log = &e->txstatlog; log->log = kcalloc(B43legacy_NR_LOGGED_TXSTATUS, sizeof(struct b43legacy_txstatus), GFP_KERNEL); if (!log->log) { b43legacyerr(dev->wl, "debugfs: add device txstatus OOM\n"); kfree(e); return; } log->end = -1; spin_lock_init(&log->lock); dev->dfsentry = e; snprintf(devdir, sizeof(devdir), "%s", wiphy_name(dev->wl->hw->wiphy)); e->subdir = debugfs_create_dir(devdir, rootdir); if (!e->subdir || IS_ERR(e->subdir)) { if (e->subdir == ERR_PTR(-ENODEV)) { b43legacydbg(dev->wl, "DebugFS (CONFIG_DEBUG_FS) not " "enabled in kernel config\n"); } else { b43legacyerr(dev->wl, "debugfs: cannot create %s directory\n", devdir); } dev->dfsentry = NULL; kfree(log->log); kfree(e); return; } #define ADD_FILE(name, mode) \ do { \ struct dentry *d; \ d = debugfs_create_file(__stringify(name), \ mode, e->subdir, dev, \ &fops_##name.fops); \ e->file_##name.dentry = NULL; \ if (!IS_ERR(d)) \ e->file_##name.dentry = d; \ } while (0) ADD_FILE(tsf, 0600); ADD_FILE(ucode_regs, 0400); ADD_FILE(shm, 0400); ADD_FILE(txstat, 0400); ADD_FILE(restart, 0200); #undef ADD_FILE b43legacy_add_dynamic_debug(dev); }
void b43legacy_debugfs_init(void) { rootdir = debugfs_create_dir(KBUILD_MODNAME, NULL); if (IS_ERR(rootdir)) rootdir = NULL; }
int mali_sysfs_register(struct mali_dev *device, dev_t dev, const char *mali_dev_name) { int err = 0; struct device * mdev; device->mali_class = class_create(THIS_MODULE, mali_dev_name); if (IS_ERR(device->mali_class)) { err = PTR_ERR(device->mali_class); goto init_class_err; } mdev = device_create(device->mali_class, NULL, dev, NULL, mali_dev_name); if (IS_ERR(mdev)) { err = PTR_ERR(mdev); goto init_mdev_err; } mali_debugfs_dir = debugfs_create_dir(mali_dev_name, NULL); if(ERR_PTR(-ENODEV) == mali_debugfs_dir) { /* Debugfs not supported. */ mali_debugfs_dir = NULL; } else { if(NULL != mali_debugfs_dir) { /* Debugfs directory created successfully; create files now */ struct dentry *mali_power_dir; struct dentry *mali_gp_dir; struct dentry *mali_pp_dir; struct dentry *mali_l2_dir; #if MALI_INTERNAL_TIMELINE_PROFILING_ENABLED struct dentry *mali_profiling_dir; #endif mali_power_dir = debugfs_create_dir("power", mali_debugfs_dir); if (mali_power_dir != NULL) { debugfs_create_file("power_events", 0400, mali_power_dir, NULL, &power_events_fops); } mali_gp_dir = debugfs_create_dir("gp", mali_debugfs_dir); if (mali_gp_dir != NULL) { struct dentry *mali_gp_all_dir; u32 ci; struct mali_cluster *cluster; mali_gp_all_dir = debugfs_create_dir("all", mali_gp_dir); if (mali_gp_all_dir != NULL) { debugfs_create_file("counter_src0", 0400, mali_gp_all_dir, NULL, &gp_all_counter_src0_fops); debugfs_create_file("counter_src1", 0400, mali_gp_all_dir, NULL, &gp_all_counter_src1_fops); } ci = 0; cluster = mali_cluster_get_global_cluster(ci); while (NULL != cluster) { u32 gi = 0; struct mali_group *group = mali_cluster_get_group(cluster, gi); while (NULL != group) { struct mali_gp_core *gp_core = mali_group_get_gp_core(group); if (NULL != gp_core) { struct dentry *mali_gp_gpx_dir; mali_gp_gpx_dir = debugfs_create_dir("gp0", mali_gp_dir); if (NULL != mali_gp_gpx_dir) { debugfs_create_file("counter_src0", 0600, mali_gp_gpx_dir, gp_core, &gp_gpx_counter_src0_fops); debugfs_create_file("counter_src1", 0600, mali_gp_gpx_dir, gp_core, &gp_gpx_counter_src1_fops); } break; /* no need to look for any other GP cores */ } /* try next group */ gi++; group = mali_cluster_get_group(cluster, gi); } /* try next cluster */ ci++; cluster = mali_cluster_get_global_cluster(ci); } } mali_pp_dir = debugfs_create_dir("pp", mali_debugfs_dir); if (mali_pp_dir != NULL) { struct dentry *mali_pp_all_dir; u32 ci; struct mali_cluster *cluster; mali_pp_all_dir = debugfs_create_dir("all", mali_pp_dir); if (mali_pp_all_dir != NULL) { debugfs_create_file("counter_src0", 0400, mali_pp_all_dir, NULL, &pp_all_counter_src0_fops); debugfs_create_file("counter_src1", 0400, mali_pp_all_dir, NULL, &pp_all_counter_src1_fops); } ci = 0; cluster = mali_cluster_get_global_cluster(ci); while (NULL != cluster) { u32 gi = 0; struct mali_group *group = mali_cluster_get_group(cluster, gi); while (NULL != group) { struct mali_pp_core *pp_core = mali_group_get_pp_core(group); if (NULL != pp_core) { char buf[16]; struct dentry *mali_pp_ppx_dir; _mali_osk_snprintf(buf, sizeof(buf), "pp%u", mali_pp_core_get_id(pp_core)); mali_pp_ppx_dir = debugfs_create_dir(buf, mali_pp_dir); if (NULL != mali_pp_ppx_dir) { debugfs_create_file("counter_src0", 0600, mali_pp_ppx_dir, pp_core, &pp_ppx_counter_src0_fops); debugfs_create_file("counter_src1", 0600, mali_pp_ppx_dir, pp_core, &pp_ppx_counter_src1_fops); } } /* try next group */ gi++; group = mali_cluster_get_group(cluster, gi); } /* try next cluster */ ci++; cluster = mali_cluster_get_global_cluster(ci); } } mali_l2_dir = debugfs_create_dir("l2", mali_debugfs_dir); if (mali_l2_dir != NULL) { struct dentry *mali_l2_all_dir; u32 l2_id; struct mali_l2_cache_core *l2_cache; mali_l2_all_dir = debugfs_create_dir("all", mali_l2_dir); if (mali_l2_all_dir != NULL) { debugfs_create_file("counter_src0", 0400, mali_l2_all_dir, NULL, &l2_all_counter_src0_fops); debugfs_create_file("counter_src1", 0400, mali_l2_all_dir, NULL, &l2_all_counter_src1_fops); } l2_id = 0; l2_cache = mali_l2_cache_core_get_glob_l2_core(l2_id); while (NULL != l2_cache) { char buf[16]; struct dentry *mali_l2_l2x_dir; _mali_osk_snprintf(buf, sizeof(buf), "l2%u", l2_id); mali_l2_l2x_dir = debugfs_create_dir(buf, mali_l2_dir); if (NULL != mali_l2_l2x_dir) { debugfs_create_file("counter_src0", 0600, mali_l2_l2x_dir, l2_cache, &l2_l2x_counter_src0_fops); debugfs_create_file("counter_src1", 0600, mali_l2_l2x_dir, l2_cache, &l2_l2x_counter_src1_fops); } /* try next L2 */ l2_id++; l2_cache = mali_l2_cache_core_get_glob_l2_core(l2_id); } } debugfs_create_file("memory_usage", 0400, mali_debugfs_dir, NULL, &memory_usage_fops); #if MALI_INTERNAL_TIMELINE_PROFILING_ENABLED mali_profiling_dir = debugfs_create_dir("profiling", mali_debugfs_dir); if (mali_profiling_dir != NULL) { struct dentry *mali_profiling_proc_dir = debugfs_create_dir("proc", mali_profiling_dir); if (mali_profiling_proc_dir != NULL) { struct dentry *mali_profiling_proc_default_dir = debugfs_create_dir("default", mali_profiling_proc_dir); if (mali_profiling_proc_default_dir != NULL) { debugfs_create_file("enable", 0600, mali_profiling_proc_default_dir, (void*)_MALI_UK_USER_SETTING_SW_EVENTS_ENABLE, &user_settings_fops); } } debugfs_create_file("record", 0600, mali_profiling_dir, NULL, &profiling_record_fops); debugfs_create_file("events", 0400, mali_profiling_dir, NULL, &profiling_events_fops); } #endif #if MALI_STATE_TRACKING debugfs_create_file("state_dump", 0400, mali_debugfs_dir, NULL, &mali_seq_internal_state_fops); #endif if (mali_sysfs_user_settings_register()) { /* Failed to create the debugfs entries for the user settings DB. */ MALI_DEBUG_PRINT(2, ("Failed to create user setting debugfs files. Ignoring...\n")); } } } /* Success! */ return 0; /* Error handling */ init_mdev_err: class_destroy(device->mali_class); init_class_err: return err; }
static int __init bfin_debug_mmrs_init(void) { struct dentry *top, *parent; pr_info("debug-mmrs: setting up Blackfin MMR debugfs\n"); top = debugfs_create_dir("blackfin", NULL); if (top == NULL) return -1; parent = debugfs_create_dir("core_regs", top); debugfs_create_file("cclk", S_IRUSR, parent, NULL, &fops_debug_cclk); debugfs_create_file("sclk", S_IRUSR, parent, NULL, &fops_debug_sclk); debugfs_create_x32("last_seqstat", S_IRUSR, parent, &last_seqstat); D_SYSREG(cycles); D_SYSREG(cycles2); D_SYSREG(emudat); D_SYSREG(seqstat); D_SYSREG(syscfg); parent = debugfs_create_dir("ctimer", top); D32(TCNTL); D32(TCOUNT); D32(TPERIOD); D32(TSCALE); parent = debugfs_create_dir("cec", top); D32(EVT0); D32(EVT1); D32(EVT2); D32(EVT3); D32(EVT4); D32(EVT5); D32(EVT6); D32(EVT7); D32(EVT8); D32(EVT9); D32(EVT10); D32(EVT11); D32(EVT12); D32(EVT13); D32(EVT14); D32(EVT15); D32(EVT_OVERRIDE); D32(IMASK); D32(IPEND); D32(ILAT); D32(IPRIO); parent = debugfs_create_dir("debug", top); D32(DBGSTAT); D32(DSPID); parent = debugfs_create_dir("mmu", top); D32(SRAM_BASE_ADDRESS); D32(DCPLB_ADDR0); D32(DCPLB_ADDR10); D32(DCPLB_ADDR11); D32(DCPLB_ADDR12); D32(DCPLB_ADDR13); D32(DCPLB_ADDR14); D32(DCPLB_ADDR15); D32(DCPLB_ADDR1); D32(DCPLB_ADDR2); D32(DCPLB_ADDR3); D32(DCPLB_ADDR4); D32(DCPLB_ADDR5); D32(DCPLB_ADDR6); D32(DCPLB_ADDR7); D32(DCPLB_ADDR8); D32(DCPLB_ADDR9); D32(DCPLB_DATA0); D32(DCPLB_DATA10); D32(DCPLB_DATA11); D32(DCPLB_DATA12); D32(DCPLB_DATA13); D32(DCPLB_DATA14); D32(DCPLB_DATA15); D32(DCPLB_DATA1); D32(DCPLB_DATA2); D32(DCPLB_DATA3); D32(DCPLB_DATA4); D32(DCPLB_DATA5); D32(DCPLB_DATA6); D32(DCPLB_DATA7); D32(DCPLB_DATA8); D32(DCPLB_DATA9); D32(DCPLB_FAULT_ADDR); D32(DCPLB_STATUS); D32(DMEM_CONTROL); D32(DTEST_COMMAND); D32(DTEST_DATA0); D32(DTEST_DATA1); D32(ICPLB_ADDR0); D32(ICPLB_ADDR1); D32(ICPLB_ADDR2); D32(ICPLB_ADDR3); D32(ICPLB_ADDR4); D32(ICPLB_ADDR5); D32(ICPLB_ADDR6); D32(ICPLB_ADDR7); D32(ICPLB_ADDR8); D32(ICPLB_ADDR9); D32(ICPLB_ADDR10); D32(ICPLB_ADDR11); D32(ICPLB_ADDR12); D32(ICPLB_ADDR13); D32(ICPLB_ADDR14); D32(ICPLB_ADDR15); D32(ICPLB_DATA0); D32(ICPLB_DATA1); D32(ICPLB_DATA2); D32(ICPLB_DATA3); D32(ICPLB_DATA4); D32(ICPLB_DATA5); D32(ICPLB_DATA6); D32(ICPLB_DATA7); D32(ICPLB_DATA8); D32(ICPLB_DATA9); D32(ICPLB_DATA10); D32(ICPLB_DATA11); D32(ICPLB_DATA12); D32(ICPLB_DATA13); D32(ICPLB_DATA14); D32(ICPLB_DATA15); D32(ICPLB_FAULT_ADDR); D32(ICPLB_STATUS); D32(IMEM_CONTROL); if (!ANOMALY_05000481) { D32(ITEST_COMMAND); D32(ITEST_DATA0); D32(ITEST_DATA1); } parent = debugfs_create_dir("perf", top); D32(PFCNTR0); D32(PFCNTR1); D32(PFCTL); parent = debugfs_create_dir("trace", top); D32(TBUF); D32(TBUFCTL); D32(TBUFSTAT); parent = debugfs_create_dir("watchpoint", top); D32(WPIACTL); D32(WPIA0); D32(WPIA1); D32(WPIA2); D32(WPIA3); D32(WPIA4); D32(WPIA5); D32(WPIACNT0); D32(WPIACNT1); D32(WPIACNT2); D32(WPIACNT3); D32(WPIACNT4); D32(WPIACNT5); D32(WPDACTL); D32(WPDA0); D32(WPDA1); D32(WPDACNT0); D32(WPDACNT1); D32(WPSTAT); #ifdef ATAPI_CONTROL parent = debugfs_create_dir("atapi", top); D16(ATAPI_CONTROL); D16(ATAPI_DEV_ADDR); D16(ATAPI_DEV_RXBUF); D16(ATAPI_DEV_TXBUF); D16(ATAPI_DMA_TFRCNT); D16(ATAPI_INT_MASK); D16(ATAPI_INT_STATUS); D16(ATAPI_LINE_STATUS); D16(ATAPI_MULTI_TIM_0); D16(ATAPI_MULTI_TIM_1); D16(ATAPI_MULTI_TIM_2); D16(ATAPI_PIO_TFRCNT); D16(ATAPI_PIO_TIM_0); D16(ATAPI_PIO_TIM_1); D16(ATAPI_REG_TIM_0); D16(ATAPI_SM_STATE); D16(ATAPI_STATUS); D16(ATAPI_TERMINATE); D16(ATAPI_UDMAOUT_TFRCNT); D16(ATAPI_ULTRA_TIM_0); D16(ATAPI_ULTRA_TIM_1); D16(ATAPI_ULTRA_TIM_2); D16(ATAPI_ULTRA_TIM_3); D16(ATAPI_UMAIN_TFRCNT); D16(ATAPI_XFER_LEN); #endif #if defined(CAN_MC1) || defined(CAN0_MC1) || defined(CAN1_MC1) parent = debugfs_create_dir("can", top); # ifdef CAN_MC1 bfin_debug_mmrs_can(parent, CAN_MC1, -1); # endif # ifdef CAN0_MC1 CAN(0); # endif # ifdef CAN1_MC1 CAN(1); # endif #endif #ifdef CNT_COMMAND parent = debugfs_create_dir("counter", top); D16(CNT_COMMAND); D16(CNT_CONFIG); D32(CNT_COUNTER); D16(CNT_DEBOUNCE); D16(CNT_IMASK); D32(CNT_MAX); D32(CNT_MIN); D16(CNT_STATUS); #endif parent = debugfs_create_dir("dmac", top); #ifdef DMAC_TC_CNT D16(DMAC_TC_CNT); D16(DMAC_TC_PER); #endif #ifdef DMAC0_TC_CNT D16(DMAC0_TC_CNT); D16(DMAC0_TC_PER); #endif #ifdef DMAC1_TC_CNT D16(DMAC1_TC_CNT); D16(DMAC1_TC_PER); #endif #ifdef DMAC1_PERIMUX D16(DMAC1_PERIMUX); #endif #ifdef __ADSPBF561__ # define DMA0_NEXT_DESC_PTR DMA2_0_NEXT_DESC_PTR # define DMA1_NEXT_DESC_PTR DMA2_1_NEXT_DESC_PTR # define DMA2_NEXT_DESC_PTR DMA2_2_NEXT_DESC_PTR # define DMA3_NEXT_DESC_PTR DMA2_3_NEXT_DESC_PTR # define DMA4_NEXT_DESC_PTR DMA2_4_NEXT_DESC_PTR # define DMA5_NEXT_DESC_PTR DMA2_5_NEXT_DESC_PTR # define DMA6_NEXT_DESC_PTR DMA2_6_NEXT_DESC_PTR # define DMA7_NEXT_DESC_PTR DMA2_7_NEXT_DESC_PTR # define DMA8_NEXT_DESC_PTR DMA2_8_NEXT_DESC_PTR # define DMA9_NEXT_DESC_PTR DMA2_9_NEXT_DESC_PTR # define DMA10_NEXT_DESC_PTR DMA2_10_NEXT_DESC_PTR # define DMA11_NEXT_DESC_PTR DMA2_11_NEXT_DESC_PTR # define DMA12_NEXT_DESC_PTR DMA1_0_NEXT_DESC_PTR # define DMA13_NEXT_DESC_PTR DMA1_1_NEXT_DESC_PTR # define DMA14_NEXT_DESC_PTR DMA1_2_NEXT_DESC_PTR # define DMA15_NEXT_DESC_PTR DMA1_3_NEXT_DESC_PTR # define DMA16_NEXT_DESC_PTR DMA1_4_NEXT_DESC_PTR # define DMA17_NEXT_DESC_PTR DMA1_5_NEXT_DESC_PTR # define DMA18_NEXT_DESC_PTR DMA1_6_NEXT_DESC_PTR # define DMA19_NEXT_DESC_PTR DMA1_7_NEXT_DESC_PTR # define DMA20_NEXT_DESC_PTR DMA1_8_NEXT_DESC_PTR # define DMA21_NEXT_DESC_PTR DMA1_9_NEXT_DESC_PTR # define DMA22_NEXT_DESC_PTR DMA1_10_NEXT_DESC_PTR # define DMA23_NEXT_DESC_PTR DMA1_11_NEXT_DESC_PTR #endif parent = debugfs_create_dir("dma", top); DMA(0); DMA(1); DMA(1); DMA(2); DMA(3); DMA(4); DMA(5); DMA(6); DMA(7); #ifdef DMA8_NEXT_DESC_PTR DMA(8); DMA(9); DMA(10); DMA(11); #endif #ifdef DMA12_NEXT_DESC_PTR DMA(12); DMA(13); DMA(14); DMA(15); DMA(16); DMA(17); DMA(18); DMA(19); #endif #ifdef DMA20_NEXT_DESC_PTR DMA(20); DMA(21); DMA(22); DMA(23); #endif parent = debugfs_create_dir("ebiu_amc", top); D32(EBIU_AMBCTL0); D32(EBIU_AMBCTL1); D16(EBIU_AMGCTL); #ifdef EBIU_MBSCTL D16(EBIU_MBSCTL); D32(EBIU_ARBSTAT); D32(EBIU_MODE); D16(EBIU_FCTL); #endif #ifdef EBIU_SDGCTL parent = debugfs_create_dir("ebiu_sdram", top); # ifdef __ADSPBF561__ D32(EBIU_SDBCTL); # else D16(EBIU_SDBCTL); # endif D32(EBIU_SDGCTL); D16(EBIU_SDRRC); D16(EBIU_SDSTAT); #endif #ifdef EBIU_DDRACCT parent = debugfs_create_dir("ebiu_ddr", top); D32(EBIU_DDRACCT); D32(EBIU_DDRARCT); D32(EBIU_DDRBRC0); D32(EBIU_DDRBRC1); D32(EBIU_DDRBRC2); D32(EBIU_DDRBRC3); D32(EBIU_DDRBRC4); D32(EBIU_DDRBRC5); D32(EBIU_DDRBRC6); D32(EBIU_DDRBRC7); D32(EBIU_DDRBWC0); D32(EBIU_DDRBWC1); D32(EBIU_DDRBWC2); D32(EBIU_DDRBWC3); D32(EBIU_DDRBWC4); D32(EBIU_DDRBWC5); D32(EBIU_DDRBWC6); D32(EBIU_DDRBWC7); D32(EBIU_DDRCTL0); D32(EBIU_DDRCTL1); D32(EBIU_DDRCTL2); D32(EBIU_DDRCTL3); D32(EBIU_DDRGC0); D32(EBIU_DDRGC1); D32(EBIU_DDRGC2); D32(EBIU_DDRGC3); D32(EBIU_DDRMCCL); D32(EBIU_DDRMCEN); D32(EBIU_DDRQUE); D32(EBIU_DDRTACT); D32(EBIU_ERRADD); D16(EBIU_ERRMST); D16(EBIU_RSTCTL); #endif #ifdef EMAC_ADDRHI parent = debugfs_create_dir("emac", top); D32(EMAC_ADDRHI); D32(EMAC_ADDRLO); D32(EMAC_FLC); D32(EMAC_HASHHI); D32(EMAC_HASHLO); D32(EMAC_MMC_CTL); D32(EMAC_MMC_RIRQE); D32(EMAC_MMC_RIRQS); D32(EMAC_MMC_TIRQE); D32(EMAC_MMC_TIRQS); D32(EMAC_OPMODE); D32(EMAC_RXC_ALIGN); D32(EMAC_RXC_ALLFRM); D32(EMAC_RXC_ALLOCT); D32(EMAC_RXC_BROAD); D32(EMAC_RXC_DMAOVF); D32(EMAC_RXC_EQ64); D32(EMAC_RXC_FCS); D32(EMAC_RXC_GE1024); D32(EMAC_RXC_LNERRI); D32(EMAC_RXC_LNERRO); D32(EMAC_RXC_LONG); D32(EMAC_RXC_LT1024); D32(EMAC_RXC_LT128); D32(EMAC_RXC_LT256); D32(EMAC_RXC_LT512); D32(EMAC_RXC_MACCTL); D32(EMAC_RXC_MULTI); D32(EMAC_RXC_OCTET); D32(EMAC_RXC_OK); D32(EMAC_RXC_OPCODE); D32(EMAC_RXC_PAUSE); D32(EMAC_RXC_SHORT); D32(EMAC_RXC_TYPED); D32(EMAC_RXC_UNICST); D32(EMAC_RX_IRQE); D32(EMAC_RX_STAT); D32(EMAC_RX_STKY); D32(EMAC_STAADD); D32(EMAC_STADAT); D32(EMAC_SYSCTL); D32(EMAC_SYSTAT); D32(EMAC_TXC_1COL); D32(EMAC_TXC_ABORT); D32(EMAC_TXC_ALLFRM); D32(EMAC_TXC_ALLOCT); D32(EMAC_TXC_BROAD); D32(EMAC_TXC_CRSERR); D32(EMAC_TXC_DEFER); D32(EMAC_TXC_DMAUND); D32(EMAC_TXC_EQ64); D32(EMAC_TXC_GE1024); D32(EMAC_TXC_GT1COL); D32(EMAC_TXC_LATECL); D32(EMAC_TXC_LT1024); D32(EMAC_TXC_LT128); D32(EMAC_TXC_LT256); D32(EMAC_TXC_LT512); D32(EMAC_TXC_MACCTL); D32(EMAC_TXC_MULTI); D32(EMAC_TXC_OCTET); D32(EMAC_TXC_OK); D32(EMAC_TXC_UNICST); D32(EMAC_TXC_XS_COL); D32(EMAC_TXC_XS_DFR); D32(EMAC_TX_IRQE); D32(EMAC_TX_STAT); D32(EMAC_TX_STKY); D32(EMAC_VLAN1); D32(EMAC_VLAN2); D32(EMAC_WKUP_CTL); D32(EMAC_WKUP_FFCMD); D32(EMAC_WKUP_FFCRC0); D32(EMAC_WKUP_FFCRC1); D32(EMAC_WKUP_FFMSK0); D32(EMAC_WKUP_FFMSK1); D32(EMAC_WKUP_FFMSK2); D32(EMAC_WKUP_FFMSK3); D32(EMAC_WKUP_FFOFF); # ifdef EMAC_PTP_ACCR D32(EMAC_PTP_ACCR); D32(EMAC_PTP_ADDEND); D32(EMAC_PTP_ALARMHI); D32(EMAC_PTP_ALARMLO); D16(EMAC_PTP_CTL); D32(EMAC_PTP_FOFF); D32(EMAC_PTP_FV1); D32(EMAC_PTP_FV2); D32(EMAC_PTP_FV3); D16(EMAC_PTP_ID_OFF); D32(EMAC_PTP_ID_SNAP); D16(EMAC_PTP_IE); D16(EMAC_PTP_ISTAT); D32(EMAC_PTP_OFFSET); D32(EMAC_PTP_PPS_PERIOD); D32(EMAC_PTP_PPS_STARTHI); D32(EMAC_PTP_PPS_STARTLO); D32(EMAC_PTP_RXSNAPHI); D32(EMAC_PTP_RXSNAPLO); D32(EMAC_PTP_TIMEHI); D32(EMAC_PTP_TIMELO); D32(EMAC_PTP_TXSNAPHI); D32(EMAC_PTP_TXSNAPLO); # endif #endif #if defined(EPPI0_STATUS) || defined(EPPI1_STATUS) || defined(EPPI2_STATUS) parent = debugfs_create_dir("eppi", top); # ifdef EPPI0_STATUS EPPI(0); # endif # ifdef EPPI1_STATUS EPPI(1); # endif # ifdef EPPI2_STATUS EPPI(2); # endif #endif parent = debugfs_create_dir("gptimer", top); #ifdef TIMER_ENABLE GPTIMER_GROUP(TIMER_ENABLE, -1); #endif #ifdef TIMER_ENABLE0 GPTIMER_GROUP(TIMER_ENABLE0, 0); #endif #ifdef TIMER_ENABLE1 GPTIMER_GROUP(TIMER_ENABLE1, 1); #endif #ifdef TMRS4_DISABLE GPTIMER_GROUP(TMRS4_ENABLE, 0); GPTIMER_GROUP(TMRS8_ENABLE, 1); #endif GPTIMER(0); GPTIMER(1); GPTIMER(2); #ifdef TIMER3_CONFIG GPTIMER(3); GPTIMER(4); GPTIMER(5); GPTIMER(6); GPTIMER(7); #endif #ifdef TIMER8_CONFIG GPTIMER(8); GPTIMER(9); GPTIMER(10); #endif #ifdef TIMER11_CONFIG GPTIMER(11); #endif #ifdef HMDMA0_CONTROL parent = debugfs_create_dir("hmdma", top); HMDMA(0); HMDMA(1); #endif #ifdef HOST_CONTROL parent = debugfs_create_dir("hostdp", top); D16(HOST_CONTROL); D16(HOST_STATUS); D16(HOST_TIMEOUT); #endif #ifdef IMDMA_S0_CONFIG parent = debugfs_create_dir("imdma", top); IMDMA(0); IMDMA(1); #endif #ifdef KPAD_CTL parent = debugfs_create_dir("keypad", top); D16(KPAD_CTL); D16(KPAD_PRESCALE); D16(KPAD_MSEL); D16(KPAD_ROWCOL); D16(KPAD_STAT); D16(KPAD_SOFTEVAL); #endif parent = debugfs_create_dir("mdma", top); MDMA(0); MDMA(1); #ifdef MDMA_D2_CONFIG MDMA(2); MDMA(3); #endif #ifdef MXVR_CONFIG parent = debugfs_create_dir("mxvr", top); D16(MXVR_CONFIG); # ifdef MXVR_PLL_CTL_0 D32(MXVR_PLL_CTL_0); # endif D32(MXVR_STATE_0); D32(MXVR_STATE_1); D32(MXVR_INT_STAT_0); D32(MXVR_INT_STAT_1); D32(MXVR_INT_EN_0); D32(MXVR_INT_EN_1); D16(MXVR_POSITION); D16(MXVR_MAX_POSITION); D16(MXVR_DELAY); D16(MXVR_MAX_DELAY); D32(MXVR_LADDR); D16(MXVR_GADDR); D32(MXVR_AADDR); D32(MXVR_ALLOC_0); D32(MXVR_ALLOC_1); D32(MXVR_ALLOC_2); D32(MXVR_ALLOC_3); D32(MXVR_ALLOC_4); D32(MXVR_ALLOC_5); D32(MXVR_ALLOC_6); D32(MXVR_ALLOC_7); D32(MXVR_ALLOC_8); D32(MXVR_ALLOC_9); D32(MXVR_ALLOC_10); D32(MXVR_ALLOC_11); D32(MXVR_ALLOC_12); D32(MXVR_ALLOC_13); D32(MXVR_ALLOC_14); D32(MXVR_SYNC_LCHAN_0); D32(MXVR_SYNC_LCHAN_1); D32(MXVR_SYNC_LCHAN_2); D32(MXVR_SYNC_LCHAN_3); D32(MXVR_SYNC_LCHAN_4); D32(MXVR_SYNC_LCHAN_5); D32(MXVR_SYNC_LCHAN_6); D32(MXVR_SYNC_LCHAN_7); D32(MXVR_DMA0_CONFIG); D32(MXVR_DMA0_START_ADDR); D16(MXVR_DMA0_COUNT); D32(MXVR_DMA0_CURR_ADDR); D16(MXVR_DMA0_CURR_COUNT); D32(MXVR_DMA1_CONFIG); D32(MXVR_DMA1_START_ADDR); D16(MXVR_DMA1_COUNT); D32(MXVR_DMA1_CURR_ADDR); D16(MXVR_DMA1_CURR_COUNT); D32(MXVR_DMA2_CONFIG); D32(MXVR_DMA2_START_ADDR); D16(MXVR_DMA2_COUNT); D32(MXVR_DMA2_CURR_ADDR); D16(MXVR_DMA2_CURR_COUNT); D32(MXVR_DMA3_CONFIG); D32(MXVR_DMA3_START_ADDR); D16(MXVR_DMA3_COUNT); D32(MXVR_DMA3_CURR_ADDR); D16(MXVR_DMA3_CURR_COUNT); D32(MXVR_DMA4_CONFIG); D32(MXVR_DMA4_START_ADDR); D16(MXVR_DMA4_COUNT); D32(MXVR_DMA4_CURR_ADDR); D16(MXVR_DMA4_CURR_COUNT); D32(MXVR_DMA5_CONFIG); D32(MXVR_DMA5_START_ADDR); D16(MXVR_DMA5_COUNT); D32(MXVR_DMA5_CURR_ADDR); D16(MXVR_DMA5_CURR_COUNT); D32(MXVR_DMA6_CONFIG); D32(MXVR_DMA6_START_ADDR); D16(MXVR_DMA6_COUNT); D32(MXVR_DMA6_CURR_ADDR); D16(MXVR_DMA6_CURR_COUNT); D32(MXVR_DMA7_CONFIG); D32(MXVR_DMA7_START_ADDR); D16(MXVR_DMA7_COUNT); D32(MXVR_DMA7_CURR_ADDR); D16(MXVR_DMA7_CURR_COUNT); D16(MXVR_AP_CTL); D32(MXVR_APRB_START_ADDR); D32(MXVR_APRB_CURR_ADDR); D32(MXVR_APTB_START_ADDR); D32(MXVR_APTB_CURR_ADDR); D32(MXVR_CM_CTL); D32(MXVR_CMRB_START_ADDR); D32(MXVR_CMRB_CURR_ADDR); D32(MXVR_CMTB_START_ADDR); D32(MXVR_CMTB_CURR_ADDR); D32(MXVR_RRDB_START_ADDR); D32(MXVR_RRDB_CURR_ADDR); D32(MXVR_PAT_DATA_0); D32(MXVR_PAT_EN_0); D32(MXVR_PAT_DATA_1); D32(MXVR_PAT_EN_1); D16(MXVR_FRAME_CNT_0); D16(MXVR_FRAME_CNT_1); D32(MXVR_ROUTING_0); D32(MXVR_ROUTING_1); D32(MXVR_ROUTING_2); D32(MXVR_ROUTING_3); D32(MXVR_ROUTING_4); D32(MXVR_ROUTING_5); D32(MXVR_ROUTING_6); D32(MXVR_ROUTING_7); D32(MXVR_ROUTING_8); D32(MXVR_ROUTING_9); D32(MXVR_ROUTING_10); D32(MXVR_ROUTING_11); D32(MXVR_ROUTING_12); D32(MXVR_ROUTING_13); D32(MXVR_ROUTING_14); # ifdef MXVR_PLL_CTL_1 D32(MXVR_PLL_CTL_1); # endif D16(MXVR_BLOCK_CNT); # ifdef MXVR_CLK_CTL D32(MXVR_CLK_CTL); # endif # ifdef MXVR_CDRPLL_CTL D32(MXVR_CDRPLL_CTL); # endif # ifdef MXVR_FMPLL_CTL D32(MXVR_FMPLL_CTL); # endif # ifdef MXVR_PIN_CTL D16(MXVR_PIN_CTL); # endif # ifdef MXVR_SCLK_CNT D16(MXVR_SCLK_CNT); # endif #endif #ifdef NFC_ADDR parent = debugfs_create_dir("nfc", top); D_WO(NFC_ADDR, 16); D_WO(NFC_CMD, 16); D_RO(NFC_COUNT, 16); D16(NFC_CTL); D_WO(NFC_DATA_RD, 16); D_WO(NFC_DATA_WR, 16); D_RO(NFC_ECC0, 16); D_RO(NFC_ECC1, 16); D_RO(NFC_ECC2, 16); D_RO(NFC_ECC3, 16); D16(NFC_IRQMASK); D16(NFC_IRQSTAT); D_WO(NFC_PGCTL, 16); D_RO(NFC_READ, 16); D16(NFC_RST); D_RO(NFC_STAT, 16); #endif #ifdef OTP_CONTROL parent = debugfs_create_dir("otp", top); D16(OTP_CONTROL); D16(OTP_BEN); D16(OTP_STATUS); D32(OTP_TIMING); D32(OTP_DATA0); D32(OTP_DATA1); D32(OTP_DATA2); D32(OTP_DATA3); #endif #ifdef PINT0_MASK_SET parent = debugfs_create_dir("pint", top); PINT(0); PINT(1); PINT(2); PINT(3); #endif #ifdef PIXC_CTL parent = debugfs_create_dir("pixc", top); D16(PIXC_CTL); D16(PIXC_PPL); D16(PIXC_LPF); D16(PIXC_AHSTART); D16(PIXC_AHEND); D16(PIXC_AVSTART); D16(PIXC_AVEND); D16(PIXC_ATRANSP); D16(PIXC_BHSTART); D16(PIXC_BHEND); D16(PIXC_BVSTART); D16(PIXC_BVEND); D16(PIXC_BTRANSP); D16(PIXC_INTRSTAT); D32(PIXC_RYCON); D32(PIXC_GUCON); D32(PIXC_BVCON); D32(PIXC_CCBIAS); D32(PIXC_TC); #endif parent = debugfs_create_dir("pll", top); D16(PLL_CTL); D16(PLL_DIV); D16(PLL_LOCKCNT); D16(PLL_STAT); D16(VR_CTL); D32(CHIPID); #if defined(PPI_CONTROL) || defined(PPI0_CONTROL) || defined(PPI1_CONTROL) parent = debugfs_create_dir("ppi", top); # ifdef PPI_CONTROL bfin_debug_mmrs_ppi(parent, PPI_CONTROL, -1); # endif # ifdef PPI0_CONTROL PPI(0); # endif # ifdef PPI1_CONTROL PPI(1); # endif #endif #ifdef PWM_CTRL parent = debugfs_create_dir("pwm", top); D16(PWM_CTRL); D16(PWM_STAT); D16(PWM_TM); D16(PWM_DT); D16(PWM_GATE); D16(PWM_CHA); D16(PWM_CHB); D16(PWM_CHC); D16(PWM_SEG); D16(PWM_SYNCWT); D16(PWM_CHAL); D16(PWM_CHBL); D16(PWM_CHCL); D16(PWM_LSI); D16(PWM_STAT2); #endif #ifdef RSI_CONFIG parent = debugfs_create_dir("rsi", top); D32(RSI_ARGUMENT); D16(RSI_CEATA_CONTROL); D16(RSI_CLK_CONTROL); D16(RSI_COMMAND); D16(RSI_CONFIG); D16(RSI_DATA_CNT); D16(RSI_DATA_CONTROL); D16(RSI_DATA_LGTH); D32(RSI_DATA_TIMER); D16(RSI_EMASK); D16(RSI_ESTAT); D32(RSI_FIFO); D16(RSI_FIFO_CNT); D32(RSI_MASK0); D32(RSI_MASK1); D16(RSI_PID0); D16(RSI_PID1); D16(RSI_PID2); D16(RSI_PID3); D16(RSI_PID4); D16(RSI_PID5); D16(RSI_PID6); D16(RSI_PID7); D16(RSI_PWR_CONTROL); D16(RSI_RD_WAIT_EN); D32(RSI_RESPONSE0); D32(RSI_RESPONSE1); D32(RSI_RESPONSE2); D32(RSI_RESPONSE3); D16(RSI_RESP_CMD); D32(RSI_STATUS); D_WO(RSI_STATUSCL, 16); #endif #ifdef RTC_ALARM parent = debugfs_create_dir("rtc", top); D32(RTC_ALARM); D16(RTC_ICTL); D16(RTC_ISTAT); D16(RTC_PREN); D32(RTC_STAT); D16(RTC_SWCNT); #endif #ifdef SDH_CFG parent = debugfs_create_dir("sdh", top); D32(SDH_ARGUMENT); D16(SDH_CFG); D16(SDH_CLK_CTL); D16(SDH_COMMAND); D_RO(SDH_DATA_CNT, 16); D16(SDH_DATA_CTL); D16(SDH_DATA_LGTH); D32(SDH_DATA_TIMER); D16(SDH_E_MASK); D16(SDH_E_STATUS); D32(SDH_FIFO); D_RO(SDH_FIFO_CNT, 16); D32(SDH_MASK0); D32(SDH_MASK1); D_RO(SDH_PID0, 16); D_RO(SDH_PID1, 16); D_RO(SDH_PID2, 16); D_RO(SDH_PID3, 16); D_RO(SDH_PID4, 16); D_RO(SDH_PID5, 16); D_RO(SDH_PID6, 16); D_RO(SDH_PID7, 16); D16(SDH_PWR_CTL); D16(SDH_RD_WAIT_EN); D_RO(SDH_RESPONSE0, 32); D_RO(SDH_RESPONSE1, 32); D_RO(SDH_RESPONSE2, 32); D_RO(SDH_RESPONSE3, 32); D_RO(SDH_RESP_CMD, 16); D_RO(SDH_STATUS, 32); D_WO(SDH_STATUS_CLR, 16); #endif #ifdef SECURE_CONTROL parent = debugfs_create_dir("security", top); D16(SECURE_CONTROL); D16(SECURE_STATUS); D32(SECURE_SYSSWT); #endif parent = debugfs_create_dir("sic", top); D16(SWRST); D16(SYSCR); D16(SIC_RVECT); D32(SIC_IAR0); D32(SIC_IAR1); D32(SIC_IAR2); #ifdef SIC_IAR3 D32(SIC_IAR3); #endif #ifdef SIC_IAR4 D32(SIC_IAR4); D32(SIC_IAR5); D32(SIC_IAR6); #endif #ifdef SIC_IAR7 D32(SIC_IAR7); #endif #ifdef SIC_IAR8 D32(SIC_IAR8); D32(SIC_IAR9); D32(SIC_IAR10); D32(SIC_IAR11); #endif #ifdef SIC_IMASK D32(SIC_IMASK); D32(SIC_ISR); D32(SIC_IWR); #endif #ifdef SIC_IMASK0 D32(SIC_IMASK0); D32(SIC_IMASK1); D32(SIC_ISR0); D32(SIC_ISR1); D32(SIC_IWR0); D32(SIC_IWR1); #endif #ifdef SIC_IMASK2 D32(SIC_IMASK2); D32(SIC_ISR2); D32(SIC_IWR2); #endif #ifdef SICB_RVECT D16(SICB_SWRST); D16(SICB_SYSCR); D16(SICB_RVECT); D32(SICB_IAR0); D32(SICB_IAR1); D32(SICB_IAR2); D32(SICB_IAR3); D32(SICB_IAR4); D32(SICB_IAR5); D32(SICB_IAR6); D32(SICB_IAR7); D32(SICB_IMASK0); D32(SICB_IMASK1); D32(SICB_ISR0); D32(SICB_ISR1); D32(SICB_IWR0); D32(SICB_IWR1); #endif parent = debugfs_create_dir("spi", top); #ifdef SPI0_REGBASE SPI(0); #endif #ifdef SPI1_REGBASE SPI(1); #endif #ifdef SPI2_REGBASE SPI(2); #endif parent = debugfs_create_dir("sport", top); #ifdef SPORT0_STAT SPORT(0); #endif #ifdef SPORT1_STAT SPORT(1); #endif #ifdef SPORT2_STAT SPORT(2); #endif #ifdef SPORT3_STAT SPORT(3); #endif #if defined(TWI_CLKDIV) || defined(TWI0_CLKDIV) || defined(TWI1_CLKDIV) parent = debugfs_create_dir("twi", top); # ifdef TWI_CLKDIV bfin_debug_mmrs_twi(parent, TWI_CLKDIV, -1); # endif # ifdef TWI0_CLKDIV TWI(0); # endif # ifdef TWI1_CLKDIV TWI(1); # endif #endif parent = debugfs_create_dir("uart", top); #ifdef BFIN_UART_DLL bfin_debug_mmrs_uart(parent, BFIN_UART_DLL, -1); #endif #ifdef UART0_DLL UART(0); #endif #ifdef UART1_DLL UART(1); #endif #ifdef UART2_DLL UART(2); #endif #ifdef UART3_DLL UART(3); #endif #ifdef USB_FADDR parent = debugfs_create_dir("usb", top); D16(USB_FADDR); D16(USB_POWER); D16(USB_INTRTX); D16(USB_INTRRX); D16(USB_INTRTXE); D16(USB_INTRRXE); D16(USB_INTRUSB); D16(USB_INTRUSBE); D16(USB_FRAME); D16(USB_INDEX); D16(USB_TESTMODE); D16(USB_GLOBINTR); D16(USB_GLOBAL_CTL); D16(USB_TX_MAX_PACKET); D16(USB_CSR0); D16(USB_TXCSR); D16(USB_RX_MAX_PACKET); D16(USB_RXCSR); D16(USB_COUNT0); D16(USB_RXCOUNT); D16(USB_TXTYPE); D16(USB_NAKLIMIT0); D16(USB_TXINTERVAL); D16(USB_RXTYPE); D16(USB_RXINTERVAL); D16(USB_TXCOUNT); D16(USB_EP0_FIFO); D16(USB_EP1_FIFO); D16(USB_EP2_FIFO); D16(USB_EP3_FIFO); D16(USB_EP4_FIFO); D16(USB_EP5_FIFO); D16(USB_EP6_FIFO); D16(USB_EP7_FIFO); D16(USB_OTG_DEV_CTL); D16(USB_OTG_VBUS_IRQ); D16(USB_OTG_VBUS_MASK); D16(USB_LINKINFO); D16(USB_VPLEN); D16(USB_HS_EOF1); D16(USB_FS_EOF1); D16(USB_LS_EOF1); D16(USB_APHY_CNTRL); D16(USB_APHY_CALIB); D16(USB_APHY_CNTRL2); D16(USB_PHY_TEST); D16(USB_PLLOSC_CTRL); D16(USB_SRP_CLKDIV); D16(USB_EP_NI0_TXMAXP); D16(USB_EP_NI0_TXCSR); D16(USB_EP_NI0_RXMAXP); D16(USB_EP_NI0_RXCSR); D16(USB_EP_NI0_RXCOUNT); D16(USB_EP_NI0_TXTYPE); D16(USB_EP_NI0_TXINTERVAL); D16(USB_EP_NI0_RXTYPE); D16(USB_EP_NI0_RXINTERVAL); D16(USB_EP_NI0_TXCOUNT); D16(USB_EP_NI1_TXMAXP); D16(USB_EP_NI1_TXCSR); D16(USB_EP_NI1_RXMAXP); D16(USB_EP_NI1_RXCSR); D16(USB_EP_NI1_RXCOUNT); D16(USB_EP_NI1_TXTYPE); D16(USB_EP_NI1_TXINTERVAL); D16(USB_EP_NI1_RXTYPE); D16(USB_EP_NI1_RXINTERVAL); D16(USB_EP_NI1_TXCOUNT); D16(USB_EP_NI2_TXMAXP); D16(USB_EP_NI2_TXCSR); D16(USB_EP_NI2_RXMAXP); D16(USB_EP_NI2_RXCSR); D16(USB_EP_NI2_RXCOUNT); D16(USB_EP_NI2_TXTYPE); D16(USB_EP_NI2_TXINTERVAL); D16(USB_EP_NI2_RXTYPE); D16(USB_EP_NI2_RXINTERVAL); D16(USB_EP_NI2_TXCOUNT); D16(USB_EP_NI3_TXMAXP); D16(USB_EP_NI3_TXCSR); D16(USB_EP_NI3_RXMAXP); D16(USB_EP_NI3_RXCSR); D16(USB_EP_NI3_RXCOUNT); D16(USB_EP_NI3_TXTYPE); D16(USB_EP_NI3_TXINTERVAL); D16(USB_EP_NI3_RXTYPE); D16(USB_EP_NI3_RXINTERVAL); D16(USB_EP_NI3_TXCOUNT); D16(USB_EP_NI4_TXMAXP); D16(USB_EP_NI4_TXCSR); D16(USB_EP_NI4_RXMAXP); D16(USB_EP_NI4_RXCSR); D16(USB_EP_NI4_RXCOUNT); D16(USB_EP_NI4_TXTYPE); D16(USB_EP_NI4_TXINTERVAL); D16(USB_EP_NI4_RXTYPE); D16(USB_EP_NI4_RXINTERVAL); D16(USB_EP_NI4_TXCOUNT); D16(USB_EP_NI5_TXMAXP); D16(USB_EP_NI5_TXCSR); D16(USB_EP_NI5_RXMAXP); D16(USB_EP_NI5_RXCSR); D16(USB_EP_NI5_RXCOUNT); D16(USB_EP_NI5_TXTYPE); D16(USB_EP_NI5_TXINTERVAL); D16(USB_EP_NI5_RXTYPE); D16(USB_EP_NI5_RXINTERVAL); D16(USB_EP_NI5_TXCOUNT); D16(USB_EP_NI6_TXMAXP); D16(USB_EP_NI6_TXCSR); D16(USB_EP_NI6_RXMAXP); D16(USB_EP_NI6_RXCSR); D16(USB_EP_NI6_RXCOUNT); D16(USB_EP_NI6_TXTYPE); D16(USB_EP_NI6_TXINTERVAL); D16(USB_EP_NI6_RXTYPE); D16(USB_EP_NI6_RXINTERVAL); D16(USB_EP_NI6_TXCOUNT); D16(USB_EP_NI7_TXMAXP); D16(USB_EP_NI7_TXCSR); D16(USB_EP_NI7_RXMAXP); D16(USB_EP_NI7_RXCSR); D16(USB_EP_NI7_RXCOUNT); D16(USB_EP_NI7_TXTYPE); D16(USB_EP_NI7_TXINTERVAL); D16(USB_EP_NI7_RXTYPE); D16(USB_EP_NI7_RXINTERVAL); D16(USB_EP_NI7_TXCOUNT); D16(USB_DMA_INTERRUPT); D16(USB_DMA0CONTROL); D16(USB_DMA0ADDRLOW); D16(USB_DMA0ADDRHIGH); D16(USB_DMA0COUNTLOW); D16(USB_DMA0COUNTHIGH); D16(USB_DMA1CONTROL); D16(USB_DMA1ADDRLOW); D16(USB_DMA1ADDRHIGH); D16(USB_DMA1COUNTLOW); D16(USB_DMA1COUNTHIGH); D16(USB_DMA2CONTROL); D16(USB_DMA2ADDRLOW); D16(USB_DMA2ADDRHIGH); D16(USB_DMA2COUNTLOW); D16(USB_DMA2COUNTHIGH); D16(USB_DMA3CONTROL); D16(USB_DMA3ADDRLOW); D16(USB_DMA3ADDRHIGH); D16(USB_DMA3COUNTLOW); D16(USB_DMA3COUNTHIGH); D16(USB_DMA4CONTROL); D16(USB_DMA4ADDRLOW); D16(USB_DMA4ADDRHIGH); D16(USB_DMA4COUNTLOW); D16(USB_DMA4COUNTHIGH); D16(USB_DMA5CONTROL); D16(USB_DMA5ADDRLOW); D16(USB_DMA5ADDRHIGH); D16(USB_DMA5COUNTLOW); D16(USB_DMA5COUNTHIGH); D16(USB_DMA6CONTROL); D16(USB_DMA6ADDRLOW); D16(USB_DMA6ADDRHIGH); D16(USB_DMA6COUNTLOW); D16(USB_DMA6COUNTHIGH); D16(USB_DMA7CONTROL); D16(USB_DMA7ADDRLOW); D16(USB_DMA7ADDRHIGH); D16(USB_DMA7COUNTLOW); D16(USB_DMA7COUNTHIGH); #endif #ifdef WDOG_CNT parent = debugfs_create_dir("watchdog", top); D32(WDOG_CNT); D16(WDOG_CTL); D32(WDOG_STAT); #endif #ifdef WDOGA_CNT parent = debugfs_create_dir("watchdog", top); D32(WDOGA_CNT); D16(WDOGA_CTL); D32(WDOGA_STAT); D32(WDOGB_CNT); D16(WDOGB_CTL); D32(WDOGB_STAT); #endif #ifdef FIO_FLAG_D #define PORTFIO FIO_FLAG_D #endif #ifdef FIO0_FLAG_D #define PORTFIO FIO0_FLAG_D #endif #ifdef FIO1_FLAG_D #define PORTGIO FIO1_FLAG_D #endif #ifdef FIO2_FLAG_D #define PORTHIO FIO2_FLAG_D #endif parent = debugfs_create_dir("port", top); #ifdef PORTFIO PORT(PORTFIO, 'F'); #endif #ifdef PORTGIO PORT(PORTGIO, 'G'); #endif #ifdef PORTHIO PORT(PORTHIO, 'H'); #endif #ifdef __ADSPBF51x__ D16(PORTF_FER); D16(PORTF_DRIVE); D16(PORTF_HYSTERESIS); D16(PORTF_MUX); D16(PORTG_FER); D16(PORTG_DRIVE); D16(PORTG_HYSTERESIS); D16(PORTG_MUX); D16(PORTH_FER); D16(PORTH_DRIVE); D16(PORTH_HYSTERESIS); D16(PORTH_MUX); D16(MISCPORT_DRIVE); D16(MISCPORT_HYSTERESIS); #endif #ifdef __ADSPBF52x__ D16(PORTF_FER); D16(PORTF_DRIVE); D16(PORTF_HYSTERESIS); D16(PORTF_MUX); D16(PORTF_SLEW); D16(PORTG_FER); D16(PORTG_DRIVE); D16(PORTG_HYSTERESIS); D16(PORTG_MUX); D16(PORTG_SLEW); D16(PORTH_FER); D16(PORTH_DRIVE); D16(PORTH_HYSTERESIS); D16(PORTH_MUX); D16(PORTH_SLEW); D16(MISCPORT_DRIVE); D16(MISCPORT_HYSTERESIS); D16(MISCPORT_SLEW); #endif #ifdef BF537_FAMILY D16(PORTF_FER); D16(PORTG_FER); D16(PORTH_FER); D16(PORT_MUX); #endif #ifdef BF538_FAMILY D16(PORTCIO_FER); D16(PORTCIO); D16(PORTCIO_CLEAR); D16(PORTCIO_SET); D16(PORTCIO_TOGGLE); D16(PORTCIO_DIR); D16(PORTCIO_INEN); D16(PORTDIO); D16(PORTDIO_CLEAR); D16(PORTDIO_DIR); D16(PORTDIO_FER); D16(PORTDIO_INEN); D16(PORTDIO_SET); D16(PORTDIO_TOGGLE); D16(PORTEIO); D16(PORTEIO_CLEAR); D16(PORTEIO_DIR); D16(PORTEIO_FER); D16(PORTEIO_INEN); D16(PORTEIO_SET); D16(PORTEIO_TOGGLE); #endif #ifdef __ADSPBF54x__ { int num; unsigned long base; base = PORTA_FER; for (num = 0; num < 10; ++num) { PORT(base, num); base += sizeof(struct bfin_gpio_regs); } } #endif debug_mmrs_dentry = top; return 0; }
static void __init __maybe_unused bfin_debug_mmrs_can(struct dentry *parent, unsigned long base, int num) { static struct dentry *am, *mb; int i, j; char buf[32], *_buf = REGS_STR_PFX(buf, CAN, num); if (!am) { am = debugfs_create_dir("am", parent); mb = debugfs_create_dir("mb", parent); } __CAN(MC1, mc1); __CAN(MD1, md1); __CAN(TRS1, trs1); __CAN(TRR1, trr1); __CAN(TA1, ta1); __CAN(AA1, aa1); __CAN(RMP1, rmp1); __CAN(RML1, rml1); __CAN(MBTIF1, mbtif1); __CAN(MBRIF1, mbrif1); __CAN(MBIM1, mbim1); __CAN(RFH1, rfh1); __CAN(OPSS1, opss1); __CAN(MC2, mc2); __CAN(MD2, md2); __CAN(TRS2, trs2); __CAN(TRR2, trr2); __CAN(TA2, ta2); __CAN(AA2, aa2); __CAN(RMP2, rmp2); __CAN(RML2, rml2); __CAN(MBTIF2, mbtif2); __CAN(MBRIF2, mbrif2); __CAN(MBIM2, mbim2); __CAN(RFH2, rfh2); __CAN(OPSS2, opss2); __CAN(CLOCK, clock); __CAN(TIMING, timing); __CAN(DEBUG, debug); __CAN(STATUS, status); __CAN(CEC, cec); __CAN(GIS, gis); __CAN(GIM, gim); __CAN(GIF, gif); __CAN(CONTROL, control); __CAN(INTR, intr); __CAN(VERSION, version); __CAN(MBTD, mbtd); __CAN(EWR, ewr); __CAN(ESR, esr); __CAN(UCCNT, uccnt); __CAN(UCRC, ucrc); __CAN(UCCNF, uccnf); __CAN(VERSION2, version2); for (i = 0; i < 32; ++i) { sprintf(_buf, "AM%02iL", i); debugfs_create_x16(buf, S_IRUSR|S_IWUSR, am, (u16 *)(base + CAN_OFF(msk[i].aml))); sprintf(_buf, "AM%02iH", i); debugfs_create_x16(buf, S_IRUSR|S_IWUSR, am, (u16 *)(base + CAN_OFF(msk[i].amh))); for (j = 0; j < 3; ++j) { sprintf(_buf, "MB%02i_DATA%i", i, j); debugfs_create_x16(buf, S_IRUSR|S_IWUSR, mb, (u16 *)(base + CAN_OFF(chl[i].data[j*2]))); } sprintf(_buf, "MB%02i_LENGTH", i); debugfs_create_x16(buf, S_IRUSR|S_IWUSR, mb, (u16 *)(base + CAN_OFF(chl[i].dlc))); sprintf(_buf, "MB%02i_TIMESTAMP", i); debugfs_create_x16(buf, S_IRUSR|S_IWUSR, mb, (u16 *)(base + CAN_OFF(chl[i].tsv))); sprintf(_buf, "MB%02i_ID0", i); debugfs_create_x16(buf, S_IRUSR|S_IWUSR, mb, (u16 *)(base + CAN_OFF(chl[i].id0))); sprintf(_buf, "MB%02i_ID1", i); debugfs_create_x16(buf, S_IRUSR|S_IWUSR, mb, (u16 *)(base + CAN_OFF(chl[i].id1))); } }
void mmc_add_host_debugfs(struct mmc_host *host) { struct dentry *root; root = debugfs_create_dir(mmc_hostname(host), NULL); if (IS_ERR(root)) /* Don't complain -- debugfs just isn't enabled */ return; if (!root) /* Complain -- debugfs is enabled, but it failed to * create the directory. */ goto err_root; host->debugfs_root = root; if (!debugfs_create_file("ios", S_IRUSR, root, host, &mmc_ios_fops)) goto err_node; if (!debugfs_create_file("clock", S_IRUSR | S_IWUSR, root, host, &mmc_clock_fops)) goto err_node; if (!debugfs_create_file("max_clock", S_IRUSR | S_IWUSR, root, host, &mmc_max_clock_fops)) goto err_node; #ifdef CONFIG_MMC_CLKGATE if (!debugfs_create_u32("clk_delay", (S_IRUSR | S_IWUSR), root, &host->clk_delay)) goto err_node; #endif #ifdef CONFIG_FAIL_MMC_REQUEST if (fail_request) setup_fault_attr(&fail_default_attr, fail_request); host->fail_mmc_request = fail_default_attr; if (IS_ERR(fault_create_debugfs_attr("fail_mmc_request", root, &host->fail_mmc_request))) goto err_node; #endif #ifdef CONFIG_MMC_CMD_LOG if (!debugfs_create_file("cmd_log", S_IRUSR, root, host, &mmc_cmd_log_fops)) goto err_node; if (!debugfs_create_file("cmd_log_mode", S_IRUSR | S_IWUSR, root, host, &mmc_cmd_log_mode_fops)) goto err_node; if (!debugfs_create_file("cmd_log_size", S_IRUSR | S_IWUSR, root, host, &mmc_cmd_log_size_fops)) goto err_node; #endif #ifdef CONFIG_MMC_CMD_LOG if (!debugfs_create_file("cmd_log", S_IRUSR, root, host, &mmc_cmd_log_fops)) goto err_node; if (!debugfs_create_file("cmd_log_mode", S_IRUSR | S_IWUSR, root, host, &mmc_cmd_log_mode_fops)) goto err_node; if (!debugfs_create_file("cmd_log_size", S_IRUSR | S_IWUSR, root, host, &mmc_cmd_log_size_fops)) goto err_node; #endif return; err_node: debugfs_remove_recursive(root); host->debugfs_root = NULL; err_root: dev_err(&host->class_dev, "failed to initialize debugfs\n"); }
void xgbe_debugfs_init(struct xgbe_prv_data *pdata) { struct dentry *pfile; char *buf; /* Set defaults */ pdata->debugfs_xgmac_reg = 0; pdata->debugfs_xpcs_mmd = 1; pdata->debugfs_xpcs_reg = 0; buf = kasprintf(GFP_KERNEL, "amd-xgbe-%s", pdata->netdev->name); if (!buf) return; pdata->xgbe_debugfs = debugfs_create_dir(buf, NULL); if (!pdata->xgbe_debugfs) { netdev_err(pdata->netdev, "debugfs_create_dir failed\n"); kfree(buf); return; } pfile = debugfs_create_file("xgmac_register", 0600, pdata->xgbe_debugfs, pdata, &xgmac_reg_addr_fops); if (!pfile) netdev_err(pdata->netdev, "debugfs_create_file failed\n"); pfile = debugfs_create_file("xgmac_register_value", 0600, pdata->xgbe_debugfs, pdata, &xgmac_reg_value_fops); if (!pfile) netdev_err(pdata->netdev, "debugfs_create_file failed\n"); pfile = debugfs_create_file("xpcs_mmd", 0600, pdata->xgbe_debugfs, pdata, &xpcs_mmd_fops); if (!pfile) netdev_err(pdata->netdev, "debugfs_create_file failed\n"); pfile = debugfs_create_file("xpcs_register", 0600, pdata->xgbe_debugfs, pdata, &xpcs_reg_addr_fops); if (!pfile) netdev_err(pdata->netdev, "debugfs_create_file failed\n"); pfile = debugfs_create_file("xpcs_register_value", 0600, pdata->xgbe_debugfs, pdata, &xpcs_reg_value_fops); if (!pfile) netdev_err(pdata->netdev, "debugfs_create_file failed\n"); if (pdata->xprop_regs) { pfile = debugfs_create_file("xprop_register", 0600, pdata->xgbe_debugfs, pdata, &xprop_reg_addr_fops); if (!pfile) netdev_err(pdata->netdev, "debugfs_create_file failed\n"); pfile = debugfs_create_file("xprop_register_value", 0600, pdata->xgbe_debugfs, pdata, &xprop_reg_value_fops); if (!pfile) netdev_err(pdata->netdev, "debugfs_create_file failed\n"); } if (pdata->xi2c_regs) { pfile = debugfs_create_file("xi2c_register", 0600, pdata->xgbe_debugfs, pdata, &xi2c_reg_addr_fops); if (!pfile) netdev_err(pdata->netdev, "debugfs_create_file failed\n"); pfile = debugfs_create_file("xi2c_register_value", 0600, pdata->xgbe_debugfs, pdata, &xi2c_reg_value_fops); if (!pfile) netdev_err(pdata->netdev, "debugfs_create_file failed\n"); } kfree(buf); }
static __init struct dentry *tegra_edp_debugfs_dir(void) { return debugfs_create_dir("edp", NULL); }
int ath9k_init_debug(struct ath_hw *ah) { struct ath_common *common = ath9k_hw_common(ah); struct ath_softc *sc = (struct ath_softc *) common->priv; sc->debug.debugfs_phy = debugfs_create_dir("ath9k", sc->hw->wiphy->debugfsdir); if (!sc->debug.debugfs_phy) return -ENOMEM; #ifdef CPTCFG_ATH_DEBUG debugfs_create_file("debug", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, sc, &fops_debug); #endif ath9k_dfs_init_debug(sc); ath9k_tx99_init_debug(sc); ath9k_spectral_init_debug(sc); debugfs_create_file("dma", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_dma); debugfs_create_file("interrupt", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_interrupt); debugfs_create_file("xmit", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_xmit); debugfs_create_file("queues", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_queues); debugfs_create_u32("qlen_bk", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, &sc->tx.txq_max_pending[IEEE80211_AC_BK]); debugfs_create_u32("qlen_be", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, &sc->tx.txq_max_pending[IEEE80211_AC_BE]); debugfs_create_u32("qlen_vi", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, &sc->tx.txq_max_pending[IEEE80211_AC_VI]); debugfs_create_u32("qlen_vo", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, &sc->tx.txq_max_pending[IEEE80211_AC_VO]); debugfs_create_file("misc", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_misc); debugfs_create_file("reset", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_reset); debugfs_create_file("recv", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_recv); debugfs_create_file("phy_err", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_phy_err); debugfs_create_u8("rx_chainmask", S_IRUSR, sc->debug.debugfs_phy, &ah->rxchainmask); debugfs_create_u8("tx_chainmask", S_IRUSR, sc->debug.debugfs_phy, &ah->txchainmask); debugfs_create_file("ani", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, sc, &fops_ani); debugfs_create_bool("paprd", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, &sc->sc_ah->config.enable_paprd); debugfs_create_file("regidx", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, sc, &fops_regidx); debugfs_create_file("regval", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, sc, &fops_regval); debugfs_create_bool("ignore_extcca", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, &ah->config.cwm_ignore_extcca); debugfs_create_file("regdump", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_regdump); debugfs_create_file("dump_nfcal", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_dump_nfcal); debugfs_create_file("base_eeprom", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_base_eeprom); debugfs_create_file("modal_eeprom", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_modal_eeprom); debugfs_create_u32("gpio_mask", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, &sc->sc_ah->gpio_mask); debugfs_create_u32("gpio_val", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, &sc->sc_ah->gpio_val); debugfs_create_file("antenna_diversity", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_antenna_diversity); #ifdef CPTCFG_ATH9K_BTCOEX_SUPPORT debugfs_create_file("bt_ant_diversity", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, sc, &fops_bt_ant_diversity); debugfs_create_file("btcoex", S_IRUSR, sc->debug.debugfs_phy, sc, &fops_btcoex); #endif return 0; }
static int fan53555_regulator_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct fan53555_device_info *di; struct fan53555_platform_data *pdata; struct regulator_config config = { }; unsigned int val; int ret; if (client->dev.of_node) pdata = fan53555_get_of_platform_data(client); else pdata = client->dev.platform_data; if (!pdata || !pdata->regulator) { dev_err(&client->dev, "Platform data not found!\n"); return -ENODEV; } di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info), GFP_KERNEL); if (!di) { dev_err(&client->dev, "Failed to allocate device info data!\n"); return -ENOMEM; } di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config); if (IS_ERR(di->regmap)) { dev_err(&client->dev, "Failed to allocate regmap!\n"); return PTR_ERR(di->regmap); } di->dev = &client->dev; di->regulator = pdata->regulator; i2c_set_clientdata(client, di); /* Get chip ID */ ret = fan53555_read(di, FAN53555_ID1, &val); if (ret < 0) { dev_err(&client->dev, "Failed to get chip ID!\n"); return -ENODEV; } di->chip_id = val & DIE_ID; /* Get chip revision */ ret = fan53555_read(di, FAN53555_ID2, &val); if (ret < 0) { dev_err(&client->dev, "Failed to get chip Rev!\n"); return -ENODEV; } di->chip_rev = val & DIE_REV; dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n", di->chip_id, di->chip_rev); /* Device init */ ret = fan53555_device_setup(di, pdata); if (ret < 0) { dev_err(&client->dev, "Failed to setup device!\n"); return ret; } /* Set up from device tree */ if (client->dev.of_node) { ret = fan53555_of_init(client->dev.of_node, di); if (ret) return ret; } /* Register regulator */ config.dev = di->dev; config.init_data = di->regulator; config.regmap = di->regmap; config.driver_data = di; config.of_node = client->dev.of_node; ret = fan53555_regulator_register(di, &config); if (ret < 0) dev_err(&client->dev, "Failed to register regulator!\n"); di->debug_root = debugfs_create_dir("fan53555", NULL); if (!di->debug_root) dev_err(&client->dev, "Couldn't create debug dir\n"); if (di->debug_root) { struct dentry *ent; ent = debugfs_create_x32("address", S_IFREG | S_IWUSR | S_IRUGO, di->debug_root, &(di->peek_poke_address)); if (!ent) dev_err(&client->dev, "Couldn't create address debug file rc = %d\n", ret); ent = debugfs_create_file("data", S_IFREG | S_IWUSR | S_IRUGO, di->debug_root, di, &poke_poke_debug_ops); if (!ent) dev_err(&client->dev, "Couldn't create data debug file rc = %d\n", ret); } return ret; }
static int adf_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { struct adf_accel_dev *accel_dev; struct adf_accel_pci *accel_pci_dev; struct adf_hw_device_data *hw_data; char name[ADF_DEVICE_NAME_LENGTH]; unsigned int i, bar_nr; int ret; switch (ent->device) { case ADF_DH895XCC_PCI_DEVICE_ID: break; default: dev_err(&pdev->dev, "Invalid device 0x%x.\n", ent->device); return -ENODEV; } if (num_possible_nodes() > 1 && dev_to_node(&pdev->dev) < 0) { /* If the accelerator is connected to a node with no memory * there is no point in using the accelerator since the remote * memory transaction will be very slow. */ dev_err(&pdev->dev, "Invalid NUMA configuration.\n"); return -EINVAL; } accel_dev = kzalloc_node(sizeof(*accel_dev), GFP_KERNEL, dev_to_node(&pdev->dev)); if (!accel_dev) return -ENOMEM; INIT_LIST_HEAD(&accel_dev->crypto_list); /* Add accel device to accel table. * This should be called before adf_cleanup_accel is called */ if (adf_devmgr_add_dev(accel_dev)) { dev_err(&pdev->dev, "Failed to add new accelerator device.\n"); kfree(accel_dev); return -EFAULT; } accel_dev->owner = THIS_MODULE; /* Allocate and configure device configuration structure */ hw_data = kzalloc_node(sizeof(*hw_data), GFP_KERNEL, dev_to_node(&pdev->dev)); if (!hw_data) { ret = -ENOMEM; goto out_err; } accel_dev->hw_device = hw_data; switch (ent->device) { case ADF_DH895XCC_PCI_DEVICE_ID: adf_init_hw_data_dh895xcc(accel_dev->hw_device); break; default: return -ENODEV; } accel_pci_dev = &accel_dev->accel_pci_dev; pci_read_config_byte(pdev, PCI_REVISION_ID, &accel_pci_dev->revid); pci_read_config_dword(pdev, ADF_DH895XCC_FUSECTL_OFFSET, &hw_data->fuses); /* Get Accelerators and Accelerators Engines masks */ hw_data->accel_mask = hw_data->get_accel_mask(hw_data->fuses); hw_data->ae_mask = hw_data->get_ae_mask(hw_data->fuses); accel_pci_dev->sku = hw_data->get_sku(hw_data); accel_pci_dev->pci_dev = pdev; /* If the device has no acceleration engines then ignore it. */ if (!hw_data->accel_mask || !hw_data->ae_mask || ((~hw_data->ae_mask) & 0x01)) { dev_err(&pdev->dev, "No acceleration units found"); ret = -EFAULT; goto out_err; } /* Create dev top level debugfs entry */ snprintf(name, sizeof(name), "%s%s_dev%d", ADF_DEVICE_NAME_PREFIX, hw_data->dev_class->name, hw_data->instance_id); accel_dev->debugfs_dir = debugfs_create_dir(name, NULL); if (!accel_dev->debugfs_dir) { dev_err(&pdev->dev, "Could not create debugfs dir\n"); ret = -EINVAL; goto out_err; } /* Create device configuration table */ ret = adf_cfg_dev_add(accel_dev); if (ret) goto out_err; pcie_set_readrq(pdev, 1024); /* enable PCI device */ if (pci_enable_device(pdev)) { ret = -EFAULT; goto out_err; } /* set dma identifier */ if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) { if ((pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))) { dev_err(&pdev->dev, "No usable DMA configuration\n"); ret = -EFAULT; goto out_err; } else { pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); } } else { pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); } if (pci_request_regions(pdev, adf_driver_name)) { ret = -EFAULT; goto out_err; } /* Read accelerator capabilities mask */ pci_read_config_dword(pdev, ADF_DH895XCC_LEGFUSE_OFFSET, &hw_data->accel_capabilities_mask); /* Find and map all the device's BARS */ for (i = 0; i < ADF_PCI_MAX_BARS; i++) { struct adf_bar *bar = &accel_pci_dev->pci_bars[i]; bar_nr = i * 2; bar->base_addr = pci_resource_start(pdev, bar_nr); if (!bar->base_addr) break; bar->size = pci_resource_len(pdev, bar_nr); bar->virt_addr = pci_iomap(accel_pci_dev->pci_dev, bar_nr, 0); if (!bar->virt_addr) { dev_err(&pdev->dev, "Failed to map BAR %d\n", i); ret = -EFAULT; goto out_err; } } pci_set_master(pdev); if (adf_enable_aer(accel_dev, &adf_driver)) { dev_err(&pdev->dev, "Failed to enable aer\n"); ret = -EFAULT; goto out_err; } if (pci_save_state(pdev)) { dev_err(&pdev->dev, "Failed to save pci state\n"); ret = -ENOMEM; goto out_err; } ret = adf_dev_configure(accel_dev); if (ret) goto out_err; ret = adf_dev_init(accel_dev); if (ret) goto out_err; ret = adf_dev_start(accel_dev); if (ret) { adf_dev_stop(accel_dev); goto out_err; } return 0; out_err: adf_cleanup_accel(accel_dev); return ret; }
void lbs_debugfs_init(void) { if (!lbs_dir) lbs_dir = debugfs_create_dir("lbs_wireless", NULL); }
int mali_sysfs_register(struct mali_dev *device, dev_t dev, const char *mali_dev_name) { int err = 0; struct device * mdev; device->mali_class = class_create(THIS_MODULE, mali_dev_name); if (IS_ERR(device->mali_class)) { err = PTR_ERR(device->mali_class); goto init_class_err; } mdev = device_create(device->mali_class, NULL, dev, NULL, mali_dev_name); if (IS_ERR(mdev)) { err = PTR_ERR(mdev); goto init_mdev_err; } mali_debugfs_dir = debugfs_create_dir(mali_dev_name, NULL); if(ERR_PTR(-ENODEV) == mali_debugfs_dir) { /* Debugfs not supported. */ mali_debugfs_dir = NULL; } else { if(NULL != mali_debugfs_dir) { /* Debugfs directory created successfully; create files now */ #if MALI_TIMELINE_PROFILING_ENABLED struct dentry *mali_profiling_dir = debugfs_create_dir("profiling", mali_debugfs_dir); if (mali_profiling_dir != NULL) { struct dentry *mali_profiling_proc_dir = debugfs_create_dir("proc", mali_profiling_dir); if (mali_profiling_proc_dir != NULL) { struct dentry *mali_profiling_proc_default_dir = debugfs_create_dir("default", mali_profiling_proc_dir); if (mali_profiling_proc_default_dir != NULL) { debugfs_create_file("enable", 0600, mali_profiling_proc_default_dir, NULL, &profiling_proc_default_enable_fops); } } debugfs_create_file("record", 0600, mali_profiling_dir, NULL, &profiling_record_fops); debugfs_create_file("events", 0400, mali_profiling_dir, NULL, &profiling_events_fops); } #endif #if MALI_STATE_TRACKING debugfs_create_file("state_dump", 0400, mali_debugfs_dir, NULL, &mali_seq_internal_state_fops); #endif debugfs_create_file("memory_usage", 0400, mali_debugfs_dir, NULL, &memory_usage_fops); } } /* Success! */ return 0; /* Error handling */ init_mdev_err: class_destroy(device->mali_class); init_class_err: return err; }
int netfront_accel_debugfs_create(netfront_accel_vnic *vnic) { #if defined(CONFIG_DEBUG_FS) if (sfc_debugfs_root == NULL) return -ENOENT; vnic->dbfs_dir = debugfs_create_dir(vnic->net_dev->name, sfc_debugfs_root); if (vnic->dbfs_dir == NULL) return -ENOMEM; vnic->netdev_dbfs.fastpath_rx_pkts = debugfs_create_u32 ("fastpath_rx_pkts", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->netdev_stats.fastpath_rx_pkts); vnic->netdev_dbfs.fastpath_rx_bytes = debugfs_create_u32 ("fastpath_rx_bytes", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->netdev_stats.fastpath_rx_bytes); vnic->netdev_dbfs.fastpath_rx_errors = debugfs_create_u32 ("fastpath_rx_errors", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->netdev_stats.fastpath_rx_errors); vnic->netdev_dbfs.fastpath_tx_pkts = debugfs_create_u32 ("fastpath_tx_pkts", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->netdev_stats.fastpath_tx_pkts); vnic->netdev_dbfs.fastpath_tx_bytes = debugfs_create_u32 ("fastpath_tx_bytes", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->netdev_stats.fastpath_tx_bytes); vnic->netdev_dbfs.fastpath_tx_errors = debugfs_create_u32 ("fastpath_tx_errors", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->netdev_stats.fastpath_tx_errors); #if NETFRONT_ACCEL_STATS vnic->dbfs.irq_count = debugfs_create_u64 ("irq_count", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.irq_count); vnic->dbfs.useless_irq_count = debugfs_create_u64 ("useless_irq_count", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.useless_irq_count); vnic->dbfs.poll_schedule_count = debugfs_create_u64 ("poll_schedule_count", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.poll_schedule_count); vnic->dbfs.poll_call_count = debugfs_create_u64 ("poll_call_count", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.poll_call_count); vnic->dbfs.poll_reschedule_count = debugfs_create_u64 ("poll_reschedule_count", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.poll_reschedule_count); vnic->dbfs.queue_stops = debugfs_create_u64 ("queue_stops", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.queue_stops); vnic->dbfs.queue_wakes = debugfs_create_u64 ("queue_wakes", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.queue_wakes); vnic->dbfs.ssr_bursts = debugfs_create_u64 ("ssr_bursts", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.ssr_bursts); vnic->dbfs.ssr_drop_stream = debugfs_create_u64 ("ssr_drop_stream", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.ssr_drop_stream); vnic->dbfs.ssr_misorder = debugfs_create_u64 ("ssr_misorder", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.ssr_misorder); vnic->dbfs.ssr_slow_start = debugfs_create_u64 ("ssr_slow_start", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.ssr_slow_start); vnic->dbfs.ssr_merges = debugfs_create_u64 ("ssr_merges", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.ssr_merges); vnic->dbfs.ssr_too_many = debugfs_create_u64 ("ssr_too_many", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.ssr_too_many); vnic->dbfs.ssr_new_stream = debugfs_create_u64 ("ssr_new_stream", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.ssr_new_stream); vnic->dbfs.fastpath_tx_busy = debugfs_create_u64 ("fastpath_tx_busy", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.fastpath_tx_busy); vnic->dbfs.fastpath_tx_completions = debugfs_create_u64 ("fastpath_tx_completions", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.fastpath_tx_completions); vnic->dbfs.fastpath_tx_pending_max = debugfs_create_u32 ("fastpath_tx_pending_max", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.fastpath_tx_pending_max); vnic->dbfs.event_count = debugfs_create_u64 ("event_count", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.event_count); vnic->dbfs.bad_event_count = debugfs_create_u64 ("bad_event_count", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.bad_event_count); vnic->dbfs.event_count_since_irq = debugfs_create_u32 ("event_count_since_irq", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.event_count_since_irq); vnic->dbfs.events_per_irq_max = debugfs_create_u32 ("events_per_irq_max", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.events_per_irq_max); vnic->dbfs.fastpath_frm_trunc = debugfs_create_u64 ("fastpath_frm_trunc", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.fastpath_frm_trunc); vnic->dbfs.fastpath_crc_bad = debugfs_create_u64 ("fastpath_crc_bad", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.fastpath_crc_bad); vnic->dbfs.fastpath_csum_bad = debugfs_create_u64 ("fastpath_csum_bad", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.fastpath_csum_bad); vnic->dbfs.fastpath_rights_bad = debugfs_create_u64 ("fastpath_rights_bad", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.fastpath_rights_bad); vnic->dbfs.fastpath_discard_other = debugfs_create_u64 ("fastpath_discard_other", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.fastpath_discard_other); vnic->dbfs.rx_no_desc_trunc = debugfs_create_u64 ("rx_no_desc_trunc", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.rx_no_desc_trunc); vnic->dbfs.events_per_poll_max = debugfs_create_u32 ("events_per_poll_max", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.events_per_poll_max); vnic->dbfs.events_per_poll_rx_max = debugfs_create_u32 ("events_per_poll_rx_max", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.events_per_poll_rx_max); vnic->dbfs.events_per_poll_tx_max = debugfs_create_u32 ("events_per_poll_tx_max", S_IRUSR | S_IRGRP | S_IROTH, vnic->dbfs_dir, &vnic->stats.events_per_poll_tx_max); #endif #endif return 0; }
static int __devinit pmic8901_dbg_probe(struct pm8901_chip *chip) { struct pm8901_dbg_device *dbgdev; struct dentry *dent; struct dentry *temp; int rc; if (chip == NULL) { pr_err("%s: no parent data passed in.\n", __func__); return -EINVAL; } dbgdev = kzalloc(sizeof *dbgdev, GFP_KERNEL); if (dbgdev == NULL) { pr_err("%s: kzalloc() failed.\n", __func__); return -ENOMEM; } dbgdev->pm_chip = chip; dbgdev->addr = -1; dent = debugfs_create_dir("pm8901-dbg", NULL); if (dent == NULL || IS_ERR(dent)) { pr_err("%s: ERR debugfs_create_dir: dent=0x%X\n", __func__, (unsigned)dent); rc = PTR_ERR(dent); goto dir_error; } temp = debugfs_create_file("addr", S_IRUSR | S_IWUSR, dent, dbgdev, &dbg_addr_fops); if (temp == NULL || IS_ERR(temp)) { pr_err("%s: ERR debugfs_create_file: dent=0x%X\n", __func__, (unsigned)temp); rc = PTR_ERR(temp); goto debug_error; } temp = debugfs_create_file("data", S_IRUSR | S_IWUSR, dent, dbgdev, &dbg_data_fops); if (temp == NULL || IS_ERR(temp)) { pr_err("%s: ERR debugfs_create_file: dent=0x%X\n", __func__, (unsigned)temp); rc = PTR_ERR(temp); goto debug_error; } mutex_init(&dbgdev->dbg_mutex); dbgdev->dent = dent; pmic_dbg_device = dbgdev; return 0; debug_error: debugfs_remove_recursive(dent); dir_error: kfree(dbgdev); return rc; }
static void bdi_debug_register(struct backing_dev_info *bdi, const char *name) { bdi->debug_dir = debugfs_create_dir(name, bdi_debug_root); bdi->debug_stats = debugfs_create_file("stats", 0444, bdi->debug_dir, bdi, &bdi_debug_stats_fops); }
void debugfs_hw_add(struct ieee80211_local *local) { struct dentry *phyd = local->hw.wiphy->debugfsdir; struct dentry *statsd; if (!phyd) return; local->debugfs.keys = debugfs_create_dir("keys", phyd); DEBUGFS_ADD(total_ps_buffered); DEBUGFS_ADD(wep_iv); DEBUGFS_ADD(queues); #ifdef CONFIG_PM DEBUGFS_ADD_MODE(reset, 0200); #endif DEBUGFS_ADD(hwflags); DEBUGFS_ADD(user_power); DEBUGFS_ADD(power); statsd = debugfs_create_dir("statistics", phyd); /* if the dir failed, don't put all the other things into the root! */ if (!statsd) return; DEBUGFS_STATS_ADD(transmitted_fragment_count, local->dot11TransmittedFragmentCount); DEBUGFS_STATS_ADD(multicast_transmitted_frame_count, local->dot11MulticastTransmittedFrameCount); DEBUGFS_STATS_ADD(failed_count, local->dot11FailedCount); DEBUGFS_STATS_ADD(retry_count, local->dot11RetryCount); DEBUGFS_STATS_ADD(multiple_retry_count, local->dot11MultipleRetryCount); DEBUGFS_STATS_ADD(frame_duplicate_count, local->dot11FrameDuplicateCount); DEBUGFS_STATS_ADD(received_fragment_count, local->dot11ReceivedFragmentCount); DEBUGFS_STATS_ADD(multicast_received_frame_count, local->dot11MulticastReceivedFrameCount); DEBUGFS_STATS_ADD(transmitted_frame_count, local->dot11TransmittedFrameCount); #ifdef CPTCFG_MAC80211_DEBUG_COUNTERS DEBUGFS_STATS_ADD(tx_handlers_drop, local->tx_handlers_drop); DEBUGFS_STATS_ADD(tx_handlers_queued, local->tx_handlers_queued); DEBUGFS_STATS_ADD(tx_handlers_drop_unencrypted, local->tx_handlers_drop_unencrypted); DEBUGFS_STATS_ADD(tx_handlers_drop_fragment, local->tx_handlers_drop_fragment); DEBUGFS_STATS_ADD(tx_handlers_drop_wep, local->tx_handlers_drop_wep); DEBUGFS_STATS_ADD(tx_handlers_drop_not_assoc, local->tx_handlers_drop_not_assoc); DEBUGFS_STATS_ADD(tx_handlers_drop_unauth_port, local->tx_handlers_drop_unauth_port); DEBUGFS_STATS_ADD(rx_handlers_drop, local->rx_handlers_drop); DEBUGFS_STATS_ADD(rx_handlers_queued, local->rx_handlers_queued); DEBUGFS_STATS_ADD(rx_handlers_drop_nullfunc, local->rx_handlers_drop_nullfunc); DEBUGFS_STATS_ADD(rx_handlers_drop_defrag, local->rx_handlers_drop_defrag); DEBUGFS_STATS_ADD(rx_handlers_drop_short, local->rx_handlers_drop_short); DEBUGFS_STATS_ADD(tx_expand_skb_head, local->tx_expand_skb_head); DEBUGFS_STATS_ADD(tx_expand_skb_head_cloned, local->tx_expand_skb_head_cloned); DEBUGFS_STATS_ADD(rx_expand_skb_head, local->rx_expand_skb_head); DEBUGFS_STATS_ADD(rx_expand_skb_head2, local->rx_expand_skb_head2); DEBUGFS_STATS_ADD(rx_handlers_fragments, local->rx_handlers_fragments); DEBUGFS_STATS_ADD(tx_status_drop, local->tx_status_drop); #endif DEBUGFS_DEVSTATS_ADD(dot11ACKFailureCount); DEBUGFS_DEVSTATS_ADD(dot11RTSFailureCount); DEBUGFS_DEVSTATS_ADD(dot11FCSErrorCount); DEBUGFS_DEVSTATS_ADD(dot11RTSSuccessCount); DEBUGFS_DEVSTATS_ADD(tx_latency); }
int mdp_debugfs_init(void) { struct dentry *dent = debugfs_create_dir("mdp", NULL); if (IS_ERR(dent)) { printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n", __FILE__, __LINE__, PTR_ERR(dent)); return -1; } if (debugfs_create_file("off", 0644, dent, 0, &mdp_off_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: index fail\n", __FILE__, __LINE__); return -1; } if (debugfs_create_file("reg", 0644, dent, 0, &mdp_reg_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } #ifdef CONFIG_FB_MSM_MDP40 if (debugfs_create_file("stat", 0644, dent, 0, &mdp_stat_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } #endif dent = debugfs_create_dir("mddi", NULL); if (IS_ERR(dent)) { printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n", __FILE__, __LINE__, PTR_ERR(dent)); return -1; } if (debugfs_create_file("reg", 0644, dent, 0, &pmdh_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } #if defined(CONFIG_FB_MSM_OVERLAY) && defined(CONFIG_FB_MSM_MDDI) if (debugfs_create_file("vsync", 0644, dent, 0, &vsync_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } #endif dent = debugfs_create_dir("emdh", NULL); if (IS_ERR(dent)) { printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n", __FILE__, __LINE__, PTR_ERR(dent)); return -1; } if (debugfs_create_file("reg", 0644, dent, 0, &emdh_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } dent = debugfs_create_dir("mdp-dbg", NULL); if (IS_ERR(dent)) { printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n", __FILE__, __LINE__, PTR_ERR(dent)); return -1; } if (debugfs_create_file("base", 0644, dent, 0, &dbg_base_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: index fail\n", __FILE__, __LINE__); return -1; } if (debugfs_create_file("off", 0644, dent, 0, &dbg_off_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: index fail\n", __FILE__, __LINE__); return -1; } if (debugfs_create_file("reg", 0644, dent, 0, &dbg_reg_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } #ifdef CONFIG_FB_MSM_HDMI_MSM_PANEL dent = debugfs_create_dir("hdmi", NULL); if (IS_ERR(dent)) { printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n", __FILE__, __LINE__, PTR_ERR(dent)); return PTR_ERR(dent); } if (debugfs_create_file("off", 0644, dent, 0, &hdmi_off_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: 'off' fail\n", __FILE__, __LINE__); return -ENOENT; } if (debugfs_create_file("reg", 0644, dent, 0, &hdmi_reg_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: 'reg' fail\n", __FILE__, __LINE__); return -ENOENT; } #endif return 0; }
int do_blk_trace_setup(struct request_queue *q, char *name, dev_t dev, struct block_device *bdev, struct blk_user_trace_setup *buts) { struct blk_trace *old_bt, *bt = NULL; struct dentry *dir = NULL; int ret, i; if (!buts->buf_size || !buts->buf_nr) return -EINVAL; strncpy(buts->name, name, BLKTRACE_BDEV_SIZE); buts->name[BLKTRACE_BDEV_SIZE - 1] = '\0'; for (i = 0; i < strlen(buts->name); i++) if (buts->name[i] == '/') buts->name[i] = '_'; bt = kzalloc(sizeof(*bt), GFP_KERNEL); if (!bt) return -ENOMEM; ret = -ENOMEM; bt->sequence = alloc_percpu(unsigned long); if (!bt->sequence) goto err; bt->msg_data = __alloc_percpu(BLK_TN_MAX_MSG, __alignof__(char)); if (!bt->msg_data) goto err; ret = -ENOENT; mutex_lock(&blk_tree_mutex); if (!blk_tree_root) { blk_tree_root = debugfs_create_dir("block", NULL); if (!blk_tree_root) { mutex_unlock(&blk_tree_mutex); goto err; } } mutex_unlock(&blk_tree_mutex); dir = debugfs_create_dir(buts->name, blk_tree_root); if (!dir) goto err; bt->dir = dir; bt->dev = dev; atomic_set(&bt->dropped, 0); ret = -EIO; bt->dropped_file = debugfs_create_file("dropped", 0444, dir, bt, &blk_dropped_fops); if (!bt->dropped_file) goto err; bt->msg_file = debugfs_create_file("msg", 0222, dir, bt, &blk_msg_fops); if (!bt->msg_file) goto err; bt->rchan = relay_open("trace", dir, buts->buf_size, buts->buf_nr, &blk_relay_callbacks, bt); if (!bt->rchan) goto err; bt->act_mask = buts->act_mask; if (!bt->act_mask) bt->act_mask = (u16) -1; blk_trace_setup_lba(bt, bdev); if (buts->start_lba) bt->start_lba = buts->start_lba; if (buts->end_lba) bt->end_lba = buts->end_lba; bt->pid = buts->pid; bt->trace_state = Blktrace_setup; ret = -EBUSY; old_bt = xchg(&q->blk_trace, bt); if (old_bt) { (void) xchg(&q->blk_trace, old_bt); goto err; } if (atomic_inc_return(&blk_probes_ref) == 1) blk_register_tracepoints(); return 0; err: blk_trace_free(bt); return ret; }
void rt2x00debug_register(struct rt2x00_dev *rt2x00dev) { const struct rt2x00debug *debug = rt2x00dev->ops->debugfs; struct rt2x00debug_intf *intf; intf = kzalloc(sizeof(struct rt2x00debug_intf), GFP_KERNEL); if (!intf) return; intf->debug = debug; intf->rt2x00dev = rt2x00dev; rt2x00dev->debugfs_intf = intf; intf->driver_folder = debugfs_create_dir(DRIVER_NAME, NULL); if (IS_ERR(intf->driver_folder)) goto exit; intf->driver_entry = rt2x00debug_create_file_driver("driver", intf, &intf->driver_blob); if (IS_ERR(intf->driver_entry)) goto exit; intf->chipset_entry = rt2x00debug_create_file_chipset("chipset", intf, &intf->chipset_blob); if (IS_ERR(intf->chipset_entry)) goto exit; #define RT2X00DEBUGFS_CREATE_ENTRY(__intf, __name) \ ({ \ (__intf)->__name##_off_entry = \ debugfs_create_u32(__stringify(__name) "_offset", \ S_IRUGO | S_IWUSR, \ (__intf)->driver_folder, \ &(__intf)->offset_##__name); \ if (IS_ERR((__intf)->__name##_off_entry)) \ goto exit; \ \ (__intf)->__name##_val_entry = \ debugfs_create_file(__stringify(__name) "_value", \ S_IRUGO | S_IWUSR, \ (__intf)->driver_folder, \ (__intf), &rt2x00debug_fop_##__name);\ if (IS_ERR((__intf)->__name##_val_entry)) \ goto exit; \ }) RT2X00DEBUGFS_CREATE_ENTRY(intf, csr); RT2X00DEBUGFS_CREATE_ENTRY(intf, eeprom); RT2X00DEBUGFS_CREATE_ENTRY(intf, bbp); RT2X00DEBUGFS_CREATE_ENTRY(intf, rf); #undef RT2X00DEBUGFS_CREATE_ENTRY return; exit: rt2x00debug_deregister(rt2x00dev); return; }
int mdp4_debugfs_init(void) { struct dentry *dent = debugfs_create_dir("mdp4", NULL); if (IS_ERR(dent)) { printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n", __FILE__, __LINE__, PTR_ERR(dent)); return -1; } if (debugfs_create_file("off", 0644, dent, 0, &mdp_off_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: index fail\n", __FILE__, __LINE__); return -1; } if (debugfs_create_file("reg", 0644, dent, 0, &mdp_reg_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } if (debugfs_create_file("stat", 0644, dent, 0, &mdp_stat_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } dent = debugfs_create_dir("mddi", NULL); if (IS_ERR(dent)) { printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n", __FILE__, __LINE__, PTR_ERR(dent)); return -1; } if (debugfs_create_file("reg", 0644, dent, 0, &pmdh_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } #ifdef MDP4_MDDI_DMA_SWITCH if (debugfs_create_file("vsync", 0644, dent, 0, &vsync_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } #endif dent = debugfs_create_dir("emdh", NULL); if (IS_ERR(dent)) { printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n", __FILE__, __LINE__, PTR_ERR(dent)); return -1; } if (debugfs_create_file("reg", 0644, dent, 0, &emdh_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } dent = debugfs_create_dir("mdp-dbg", NULL); if (IS_ERR(dent)) { printk(KERN_ERR "%s(%d): debugfs_create_dir fail, error %ld\n", __FILE__, __LINE__, PTR_ERR(dent)); return -1; } if (debugfs_create_file("base", 0644, dent, 0, &dbg_base_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: index fail\n", __FILE__, __LINE__); return -1; } if (debugfs_create_file("off", 0644, dent, 0, &dbg_off_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: index fail\n", __FILE__, __LINE__); return -1; } if (debugfs_create_file("reg", 0644, dent, 0, &dbg_reg_fops) == NULL) { printk(KERN_ERR "%s(%d): debugfs_create_file: debug fail\n", __FILE__, __LINE__); return -1; } return 0; }