コード例 #1
0
static void *
indra_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir)
{
	struct indra_priv *ip;

	ip = kzalloc(sizeof(struct indra_priv), GFP_ATOMIC);
	if (!ip)
		return NULL;
		
	ip->cw_min = 15;

	if (hw->max_rate_tries > 0)
		ip->max_retry = hw->max_rate_tries;
	else
		/* safe default, does not necessarily have to match hw properties */
		ip->max_retry = 7;

	if (hw->max_rates >= 4)
		ip->has_mrr = true;

	ip->hw = hw;
	
#ifdef CPTCFG_MAC80211_DEBUGFS
	ip->st_deadline = (u32) 2000;
	ip->dbg_st_deadline = debugfs_create_u32("deadline",
			S_IRUGO | S_IWUGO, debugfsdir, &ip->st_deadline);
	ip->ref_payload_size = (u32) 100;											
	ip->dbg_ref_payload_size = debugfs_create_u32("ref_payload_size",			
			S_IRUGO | S_IWUGO, debugfsdir, &ip->ref_payload_size);				
#endif

	indra_init_cck_rates(ip);

	return ip;
}
コード例 #2
0
static int __init simon_debugfs_init(void)
{
	int i;
	struct tegra_simon_grader *grader;
	struct dentry *dir;

	dir = debugfs_create_dir("tegra_simon", NULL);
	if (!dir)
		return -ENOMEM;

	if (!debugfs_create_u32("grading_sec", S_IWUSR | S_IRUGO, dir,
				&grading_sec))
		goto err_out;

	if (!debugfs_create_u32("timeout_sec", S_IWUSR | S_IRUGO, dir,
				&timeout_sec))
		goto err_out;

	for (i = 0; i < TEGRA_SIMON_DOMAIN_NUM; i++) {
		grader = &simon_graders[i];

		if (!grader->domain_name)
			continue;

		if (simon_debugfs_init_domain(dir, grader))
			goto err_out;
	}

	return 0;

err_out:
	debugfs_remove_recursive(dir);
	return -ENOMEM;
}
コード例 #3
0
void fpga_mgr_debugfs_add(struct fpga_manager *mgr)
{
	struct fpga_mgr_debugfs *debugfs;
	struct fpga_image_info *info;

	if (!fpga_mgr_debugfs_root)
		return;

	debugfs = kzalloc(sizeof(*debugfs), GFP_KERNEL);
	if (!debugfs)
		return;

	debugfs->debugfs_dir = debugfs_create_dir(dev_name(&mgr->dev),
						  fpga_mgr_debugfs_root);

	debugfs_create_file("firmware_name", 0600, debugfs->debugfs_dir, mgr,
			    &fpga_mgr_firmware_fops);

	debugfs_create_file("image", 0200, debugfs->debugfs_dir, mgr,
			    &fpga_mgr_image_fops);

	info = &debugfs->info;
	debugfs_create_u32("flags", 0600, debugfs->debugfs_dir, &info->flags);
	debugfs_create_u32("enable_to", 0600, debugfs->debugfs_dir,
			   &info->enable_timeout_us);
	debugfs_create_u32("disable_to", 0600, debugfs->debugfs_dir,
			   &info->disable_timeout_us);
	debugfs_create_u32("config_to", 0600, debugfs->debugfs_dir,
			   &info->config_complete_timeout_us);

	mgr->debugfs = debugfs;
}
コード例 #4
0
static int pfn_inject_init(void)
{
	struct dentry *dentry;

	hwpoison_dir = debugfs_create_dir("hwpoison", NULL);
	if (hwpoison_dir == NULL)
		return -ENOMEM;

	/*
	 * Note that the below poison/unpoison interfaces do not involve
	 * hardware status change, hence do not require hardware support.
	 * They are mainly for testing hwpoison in software level.
	 */
	dentry = debugfs_create_file("corrupt-pfn", 0600, hwpoison_dir,
					  NULL, &hwpoison_fops);
	if (!dentry)
		goto fail;

	dentry = debugfs_create_file("unpoison-pfn", 0600, hwpoison_dir,
				     NULL, &unpoison_fops);
	if (!dentry)
		goto fail;

	dentry = debugfs_create_u32("corrupt-filter-enable", 0600,
				    hwpoison_dir, &hwpoison_filter_enable);
	if (!dentry)
		goto fail;

	dentry = debugfs_create_u32("corrupt-filter-dev-major", 0600,
				    hwpoison_dir, &hwpoison_filter_dev_major);
	if (!dentry)
		goto fail;

	dentry = debugfs_create_u32("corrupt-filter-dev-minor", 0600,
				    hwpoison_dir, &hwpoison_filter_dev_minor);
	if (!dentry)
		goto fail;

	dentry = debugfs_create_u64("corrupt-filter-flags-mask", 0600,
				    hwpoison_dir, &hwpoison_filter_flags_mask);
	if (!dentry)
		goto fail;

	dentry = debugfs_create_u64("corrupt-filter-flags-value", 0600,
				    hwpoison_dir, &hwpoison_filter_flags_value);
	if (!dentry)
		goto fail;

#ifdef CONFIG_MEMCG_SWAP
	dentry = debugfs_create_u64("corrupt-filter-memcg", 0600,
				    hwpoison_dir, &hwpoison_filter_memcg);
	if (!dentry)
		goto fail;
#endif

	return 0;
fail:
	pfn_inject_exit();
	return -ENOMEM;
}
コード例 #5
0
ファイル: debug.c プロジェクト: 020gzh/linux
static void host1x_debugfs_init(struct host1x *host1x)
{
	struct dentry *de = debugfs_create_dir("tegra-host1x", NULL);

	if (!de)
		return;

	/* Store the created entry */
	host1x->debugfs = de;

	debugfs_create_file("status", S_IRUGO, de, host1x, &host1x_debug_fops);
	debugfs_create_file("status_all", S_IRUGO, de, host1x,
			    &host1x_debug_all_fops);

	debugfs_create_u32("trace_cmdbuf", S_IRUGO|S_IWUSR, de,
			   &host1x_debug_trace_cmdbuf);

	host1x_hw_debug_init(host1x, de);

	debugfs_create_u32("force_timeout_pid", S_IRUGO|S_IWUSR, de,
			   &host1x_debug_force_timeout_pid);
	debugfs_create_u32("force_timeout_val", S_IRUGO|S_IWUSR, de,
			   &host1x_debug_force_timeout_val);
	debugfs_create_u32("force_timeout_channel", S_IRUGO|S_IWUSR, de,
			   &host1x_debug_force_timeout_channel);
}
コード例 #6
0
void adreno_debugfs_init(struct kgsl_device *device)
{
	struct adreno_device *adreno_dev = ADRENO_DEVICE(device);

	if (!device->d_debugfs || IS_ERR(device->d_debugfs))
		return;

	debugfs_create_file("cff_dump", 0644, device->d_debugfs, device,
			    &kgsl_cff_dump_enable_fops);
	debugfs_create_u32("wait_timeout", 0644, device->d_debugfs,
		&adreno_dev->wait_timeout);
	debugfs_create_u32("ib_check", 0644, device->d_debugfs,
			   &adreno_dev->ib_check_level);

	/* By Default enable fast hang detection */
	adreno_dev->fast_hang_detect = 1;
	debugfs_create_u32("fast_hang_detect", 0644, device->d_debugfs,
			   &adreno_dev->fast_hang_detect);

	/* Create post mortem control files */

	pm_d_debugfs = debugfs_create_dir("postmortem", device->d_debugfs);

	if (IS_ERR(pm_d_debugfs))
		return;

	debugfs_create_file("dump",  0600, pm_d_debugfs, device,
			    &pm_dump_fops);
	debugfs_create_file("regs_enabled", 0644, pm_d_debugfs, device,
			    &pm_regs_enabled_fops);
	debugfs_create_file("ib_enabled", 0644, pm_d_debugfs, device,
				    &pm_ib_enabled_fops);
}
コード例 #7
0
static void init_debug(void)
{
	struct dentry *dd, *df;

	if (!sysedp_debugfs_dir)
		return;

	dd = debugfs_create_dir("batmon", sysedp_debugfs_dir);
	WARN_ON(IS_ERR_OR_NULL(dd));

	df = debugfs_create_file("rbat", S_IRUGO, dd, NULL, &rbat_fops);
	WARN_ON(IS_ERR_OR_NULL(df));

	df = debugfs_create_file("ibat", S_IRUGO, dd, NULL, &ibat_fops);
	WARN_ON(IS_ERR_OR_NULL(df));

	df = debugfs_create_file("ocv", S_IRUGO, dd, NULL, &ocv_fops);
	WARN_ON(IS_ERR_OR_NULL(df));

	df = debugfs_create_u32("r_const", S_IRUGO, dd, &pdata->r_const);
	WARN_ON(IS_ERR_OR_NULL(df));

	df = debugfs_create_u32("vsys_min", S_IRUGO, dd, &pdata->vsys_min);
	WARN_ON(IS_ERR_OR_NULL(df));
}
コード例 #8
0
void abe_init_debugfs(struct omap_abe *abe)
{
    abe->debugfs.d_root = debugfs_create_dir("omap-abe", NULL);
    if (!abe->debugfs.d_root) {
        dev_err(abe->dev, "Failed to create debugfs directory\n");
        return;
    }

    abe->debugfs.d_fmt1 = debugfs_create_bool("format1", 0644,
                          abe->debugfs.d_root,
                          &abe->debugfs.format1);
    if (!abe->debugfs.d_fmt1)
        dev_err(abe->dev, "Failed to create format1 debugfs file\n");

    abe->debugfs.d_fmt2 = debugfs_create_bool("format2", 0644,
                          abe->debugfs.d_root,
                          &abe->debugfs.format2);
    if (!abe->debugfs.d_fmt2)
        dev_err(abe->dev, "Failed to create format2 debugfs file\n");

    abe->debugfs.d_fmt3 = debugfs_create_bool("format3", 0644,
                          abe->debugfs.d_root,
                          &abe->debugfs.format3);
    if (!abe->debugfs.d_fmt3)
        dev_err(abe->dev, "Failed to create format3 debugfs file\n");

    abe->debugfs.d_elem_bytes = debugfs_create_u32("element_bytes", 0604,
                                abe->debugfs.d_root,
                                &abe->debugfs.elem_bytes);
    if (!abe->debugfs.d_elem_bytes)
        dev_err(abe->dev, "Failed to create element size debugfs file\n");

    abe->debugfs.d_size = debugfs_create_u32("msecs", 0644,
                          abe->debugfs.d_root,
                          &abe->debugfs.buffer_msecs);
    if (!abe->debugfs.d_size)
        dev_err(abe->dev, "Failed to create buffer size debugfs file\n");

    abe->debugfs.d_circ = debugfs_create_bool("circular", 0644,
                          abe->debugfs.d_root,
                          &abe->debugfs.circular);
    if (!abe->debugfs.d_size)
        dev_err(abe->dev, "Failed to create circular mode debugfs file\n");

    abe->debugfs.d_data = debugfs_create_file("debug", 0644,
                          abe->debugfs.d_root,
                          abe, &omap_abe_fops);
    if (!abe->debugfs.d_data)
        dev_err(abe->dev, "Failed to create data debugfs file\n");

    abe->debugfs.d_opp = debugfs_create_u32("opp_level", 0604,
                                            abe->debugfs.d_root,
                                            &abe->opp.level);
    if (!abe->debugfs.d_opp)
        dev_err(abe->dev, "Failed to create OPP level debugfs file\n");

    init_waitqueue_head(&abe->debugfs.wait);
}
コード例 #9
0
int __init balong_compose_debug_init(void)
{
    debugfs_create_u32("mit1_compose", 0664, NULL, &g_command_file_wr_enable);
    debugfs_create_u32("mit1_ade_off", 0664, NULL, &g_ade_power_off_enable);
    debugfs_create_u32("mit1_ade_isr_off", 0664, NULL, &g_ade_isr_disable);
    debugfs_create_u32("mit1_offline_disable", 0664, NULL, &g_ade_offline_disable);
    debugfs_create_u32("mit1_dis_ade_ioctl", 0664, NULL, &g_debug_dis_ade_ioctl);
    return 0;
}
コード例 #10
0
ファイル: debugfs.c プロジェクト: AkyZero/wrapfs-latest
int wil6210_debugfs_init(struct wil6210_priv *wil)
{
	struct dentry *dbg = wil->debug = debugfs_create_dir(WIL_NAME,
			wil_to_wiphy(wil)->debugfsdir);

	if (IS_ERR_OR_NULL(dbg))
		return -ENODEV;

	debugfs_create_file("mbox", S_IRUGO, dbg, wil, &fops_mbox);
	debugfs_create_file("vrings", S_IRUGO, dbg, wil, &fops_vring);
	debugfs_create_file("stations", S_IRUGO, dbg, wil, &fops_sta);
	debugfs_create_file("desc", S_IRUGO, dbg, wil, &fops_txdesc);
	debugfs_create_u32("desc_index", S_IRUGO | S_IWUSR, dbg,
			   &dbg_txdesc_index);
	debugfs_create_u32("vring_index", S_IRUGO | S_IWUSR, dbg,
			   &dbg_vring_index);

	debugfs_create_file("bf", S_IRUGO, dbg, wil, &fops_bf);
	debugfs_create_file("ssid", S_IRUGO | S_IWUSR, dbg, wil, &fops_ssid);
	debugfs_create_u32("secure_pcp", S_IRUGO | S_IWUSR, dbg,
			   &wil->secure_pcp);
	wil_debugfs_create_ulong("status", S_IRUGO | S_IWUSR, dbg,
				 &wil->status);
	debugfs_create_u32("fw_version", S_IRUGO, dbg, &wil->fw_version);
	debugfs_create_x32("hw_version", S_IRUGO, dbg, &wil->hw_version);

	wil6210_debugfs_create_ISR(wil, "USER_ICR", dbg,
				   HOSTADDR(RGF_USER_USER_ICR));
	wil6210_debugfs_create_ISR(wil, "DMA_EP_TX_ICR", dbg,
				   HOSTADDR(RGF_DMA_EP_TX_ICR));
	wil6210_debugfs_create_ISR(wil, "DMA_EP_RX_ICR", dbg,
				   HOSTADDR(RGF_DMA_EP_RX_ICR));
	wil6210_debugfs_create_ISR(wil, "DMA_EP_MISC_ICR", dbg,
				   HOSTADDR(RGF_DMA_EP_MISC_ICR));
	wil6210_debugfs_create_pseudo_ISR(wil, dbg);
	wil6210_debugfs_create_ITR_CNT(wil, dbg);

	wil_debugfs_create_iomem_x32("RGF_USER_USAGE_1", S_IRUGO, dbg,
				     wil->csr +
				     HOSTADDR(RGF_USER_USAGE_1));
	debugfs_create_u32("mem_addr", S_IRUGO | S_IWUSR, dbg, &mem_addr);
	debugfs_create_file("mem_val", S_IRUGO, dbg, wil, &fops_memread);

	debugfs_create_file("reset", S_IWUSR, dbg, wil, &fops_reset);
	debugfs_create_file("rxon", S_IWUSR, dbg, wil, &fops_rxon);
	debugfs_create_file("tx_mgmt", S_IWUSR, dbg, wil, &fops_txmgmt);
	debugfs_create_file("wmi_send", S_IWUSR, dbg, wil, &fops_wmi);
	debugfs_create_file("temp", S_IRUGO, dbg, wil, &fops_temp);
	debugfs_create_file("freq", S_IRUGO, dbg, wil, &fops_freq);
	debugfs_create_file("link", S_IRUGO, dbg, wil, &fops_link);
	debugfs_create_file("info", S_IRUGO, dbg, wil, &fops_info);

	wil6210_debugfs_init_blobs(wil, dbg);

	return 0;
}
コード例 #11
0
ファイル: pm_debug_scx35.c プロジェクト: bigzz/sc7715-kernel
static void debugfs_init(void)
{
	dentry_debug_root = debugfs_create_dir("power", NULL);
	if (IS_ERR(dentry_debug_root) || !dentry_debug_root) {
		printk("!!!powermanager Failed to create debugfs directory\n");
		dentry_debug_root = NULL;
		return;
	}
	debugfs_create_u32("print_sleep_mode", 0644, dentry_debug_root,
			   &is_print_sleep_mode);
	debugfs_create_u32("print_linux_clock", 0644, dentry_debug_root,
			   &is_print_linux_clock);
	debugfs_create_u32("print_modem_clock", 0644, dentry_debug_root,
			   &is_print_modem_clock);
	debugfs_create_u32("print_irq", 0644, dentry_debug_root,
			   &is_print_irq);
	debugfs_create_u32("print_wakeup", 0644, dentry_debug_root,
			   &is_print_wakeup);
	debugfs_create_u32("print_irq_runtime", 0644, dentry_debug_root,
			   &is_print_irq_runtime);
	debugfs_create_u32("print_time", 0644, dentry_debug_root,
			   &is_print_time);
	debugfs_create_u32("print_thread_enable", 0644, dentry_debug_root,
			   &print_thread_enable);
	debugfs_create_u32("print_thread_interval", 0644, dentry_debug_root,
			   &print_thread_interval);
}
コード例 #12
0
ファイル: mdss_panel.c プロジェクト: auras76/aur-kernel-XZxx
int mdss_panel_debugfs_setup(struct mdss_panel_info *panel_info, struct dentry
		*parent, char *dsi_str)
{
	struct mdss_panel_debugfs_info *debugfs_info;
	debugfs_info = kzalloc(sizeof(*debugfs_info), GFP_KERNEL);
	if (!debugfs_info) {
		pr_err("No memory to create panel debugfs info");
		return -ENOMEM;
	}

	debugfs_info->root = debugfs_create_dir(dsi_str, parent);
	if (IS_ERR_OR_NULL(debugfs_info->root)) {
		pr_err("Debugfs create dir failed with error: %ld\n",
					PTR_ERR(debugfs_info->root));
		kfree(debugfs_info);
		return -ENODEV;
	}

	debugfs_create_u32("override_flag", 0644, parent,
			(u32 *)&debugfs_info->override_flag);

	debugfs_create_u32("xres", 0644, debugfs_info->root,
			(u32 *)&debugfs_info->xres);
	debugfs_create_u32("yres", 0644, debugfs_info->root,
					(u32 *)&debugfs_info->yres);

	debugfs_create_u32("h_back_porch", 0644, debugfs_info->root,
			(u32 *)&debugfs_info->lcdc.h_back_porch);
	debugfs_create_u32("h_front_porch", 0644, debugfs_info->root,
			(u32 *)&debugfs_info->lcdc.h_front_porch);
	debugfs_create_u32("h_pulse_width", 0644, debugfs_info->root,
			(u32 *)&debugfs_info->lcdc.h_pulse_width);

	debugfs_create_u32("v_back_porch", 0644, debugfs_info->root,
			(u32 *)&debugfs_info->lcdc.v_back_porch);
	debugfs_create_u32("v_front_porch", 0644, debugfs_info->root,
			(u32 *)&debugfs_info->lcdc.v_front_porch);
	debugfs_create_u32("v_pulse_width", 0644, debugfs_info->root,
			(u32 *)&debugfs_info->lcdc.v_pulse_width);

	debugfs_create_u32("frame_rate", 0644, parent,
			(u32 *)&debugfs_info->frame_rate);

	mdss_panel_debugfs_fbc_setup(debugfs_info, panel_info,
		debugfs_info->root);

	debugfs_info->xres = panel_info->xres;
	debugfs_info->yres = panel_info->yres;
	debugfs_info->lcdc = panel_info->lcdc;
	debugfs_info->frame_rate = panel_info->mipi.frame_rate;
	debugfs_info->override_flag = 0;

	panel_info->debugfs_info = debugfs_info;
	return 0;
}
コード例 #13
0
struct dentry *msm_vidc_debugfs_init_core(struct msm_vidc_core *core,
		struct dentry *parent)
{
	struct dentry *dir = NULL;
	char debugfs_name[MAX_DEBUGFS_NAME];
	if (!core) {
		dprintk(VIDC_ERR, "Invalid params, core: %p\n", core);
		goto failed_create_dir;
	}

	snprintf(debugfs_name, MAX_DEBUGFS_NAME, "core%d", core->id);
	dir = debugfs_create_dir(debugfs_name, parent);
	if (!dir) {
		dprintk(VIDC_ERR, "Failed to create debugfs for msm_vidc\n");
		goto failed_create_dir;
	}
	if (!debugfs_create_file("info", S_IRUGO, dir, core, &core_info_fops)) {
		dprintk(VIDC_ERR, "debugfs_create_file: fail\n");
		goto failed_create_dir;
	}
	if (!debugfs_create_u32("debug_level", S_IRUGO | S_IWUSR,
			parent,	&msm_vidc_debug)) {
		dprintk(VIDC_ERR, "debugfs_create_file: fail\n");
		goto failed_create_dir;
	}
	if (!debugfs_create_u32("fw_level", S_IRUGO | S_IWUSR,
			parent, &msm_fw_debug)) {
		dprintk(VIDC_ERR, "debugfs_create_file: fail\n");
		goto failed_create_dir;
	}
	if (!debugfs_create_file("trigger_ssr", S_IWUSR,
			dir, core, &ssr_fops)) {
		dprintk(VIDC_ERR, "debugfs_create_file: fail\n");
		goto failed_create_dir;
	}
	if (!debugfs_create_u32("fw_debug_mode", S_IRUGO | S_IWUSR,
			parent, &msm_fw_debug_mode)) {
		dprintk(VIDC_ERR, "debugfs_create_file: fail\n");
		goto failed_create_dir;
	}
	if (!debugfs_create_u32("fw_low_power_mode", S_IRUGO | S_IWUSR,
			parent, &msm_fw_low_power_mode)) {
		dprintk(VIDC_ERR, "debugfs_create_file: fail\n");
		goto failed_create_dir;
	}
	if (!debugfs_create_u32("vp8_low_tier", S_IRUGO | S_IWUSR,
			parent, &msm_vp8_low_tier)) {
		dprintk(VIDC_ERR, "debugfs_create_file: fail\n");
		goto failed_create_dir;
	}
failed_create_dir:
	return dir;
}
コード例 #14
0
ファイル: caif_virtio.c プロジェクト: ReneNyffenegger/linux
/* Create debugfs counters for the device */
static inline void debugfs_init(struct cfv_info *cfv)
{
	cfv->debugfs =
		debugfs_create_dir(netdev_name(cfv->ndev), NULL);

	if (IS_ERR(cfv->debugfs))
		return;

	debugfs_create_u32("rx-napi-complete", S_IRUSR, cfv->debugfs,
			   &cfv->stats.rx_napi_complete);
	debugfs_create_u32("rx-napi-resched", S_IRUSR, cfv->debugfs,
			   &cfv->stats.rx_napi_resched);
	debugfs_create_u32("rx-nomem", S_IRUSR, cfv->debugfs,
			   &cfv->stats.rx_nomem);
	debugfs_create_u32("rx-kicks", S_IRUSR, cfv->debugfs,
			   &cfv->stats.rx_kicks);
	debugfs_create_u32("tx-full-ring", S_IRUSR, cfv->debugfs,
			   &cfv->stats.tx_full_ring);
	debugfs_create_u32("tx-no-mem", S_IRUSR, cfv->debugfs,
			   &cfv->stats.tx_no_mem);
	debugfs_create_u32("tx-kicks", S_IRUSR, cfv->debugfs,
			   &cfv->stats.tx_kicks);
	debugfs_create_u32("tx-flow-on", S_IRUSR, cfv->debugfs,
			   &cfv->stats.tx_flow_on);
}
int tegra_emc_timers_init(struct dentry *parent)
{
#ifdef CONFIG_DEBUG_FS
	struct dentry *dram_therm_debugfs;
	struct dentry *training_debugfs;

	/*
	 * If caller doesn't want us to make a debugfs dir it can pass NULL.
	 * This should never be a top level debugfs dir. For subsequent debugfs
	 * errors return 0 - don't fail the entire EMC driver init if debugfs
	 * has problems. We do a best effort here.
	 */
	if (!parent)
		return 0;

	emc_timers_debugfs = debugfs_create_dir("emc_timers", parent);
	if (!emc_timers_debugfs)
		return 0;

	dram_therm_debugfs = debugfs_create_dir("dram_therm",
						emc_timers_debugfs);
	if (!dram_therm_debugfs)
		return 0;

	debugfs_create_u32("debug", S_IRUGO | S_IWUSR,
			   emc_timers_debugfs, &emc_timers_dbg);

	/* DRAM thermals. */
	debugfs_create_u32("timer_period", S_IRUGO | S_IWUSR,
			   dram_therm_debugfs, &timer_period_mr4);
	debugfs_create_u32("test_mode", S_IRUGO | S_IWUSR,
			   dram_therm_debugfs, &test_mode);
	debugfs_create_u32("dram_temp_override", S_IRUGO | S_IWUSR,
			   dram_therm_debugfs, &dram_temp_override);
	debugfs_create_file("force_poll", S_IRUGO | S_IWUSR,
			    dram_therm_debugfs, NULL, &mr4_force_poll_fops);

	if (tegra_emc_get_dram_type() == DRAM_TYPE_LPDDR4) {
		/* Training. */
		training_debugfs = debugfs_create_dir("training",
						      emc_timers_debugfs);
		if (!training_debugfs)
			return 0;

		debugfs_create_u32("timer_period", S_IRUGO | S_IWUSR,
				   training_debugfs, &timer_period_training);
	}
#endif
	return 0;
}
コード例 #16
0
int __init rhea_pm_debug_init(void)
{
	int ret;

    INIT_DELAYED_WORK(&uartb_wq, uartb_wq_handler);
#ifdef CONFIG_UART_FORCE_RETENTION_TST
	if (pwr_mgr_register_event_handler(UBRX_EVENT,
			uartb_pwr_mgr_event_cb, NULL))
		return -ENOMEM;
#endif
	/* create root clock dir /clock */
    dent_rhea_pm_root_dir = debugfs_create_dir("rhea_pm", 0);
    if(!dent_rhea_pm_root_dir)
	return -ENOMEM;
	if (!debugfs_create_u32("log_mask", S_IRUGO | S_IWUSR,
		dent_rhea_pm_root_dir, (int *)&log_mask))
		return -ENOMEM;
	if (!debugfs_create_file("en_self_refresh", S_IRUGO | S_IWUSR,
		dent_rhea_pm_root_dir, NULL, &pm_en_self_refresh_fops))
		return -ENOMEM;
	if (!debugfs_create_u32("force_retention", S_IRUGO | S_IWUSR,
			dent_rhea_pm_root_dir, (int*)&force_retention))
		return -ENOMEM;

	/* A9 QOS interface is used to disable dormant C-states
	 * at runtime. To disable dormant set PM_QOS_CPU_DMA_LATENCY
	 * to the latency of the highest non-dormant state.
	 */
	ret = pi_mgr_qos_add_request(&arm_qos, "pm",
				     PI_MGR_PI_ID_ARM_CORE,
				     PI_MGR_QOS_DEFAULT_VALUE);
	if (ret < 0)
		return ret;

	/* If dormant is not enabled out of boot, prevent cpuidle
	 * from entering into dormant C-states.
	 */
	if (dormant_enable == 0)
		pi_mgr_qos_request_update(&arm_qos,
					  NON_DORMANT_MAX_EXIT_LATENCY);

	/* Interface to enable disable dormant mode at runtime */
	if (!debugfs_create_file("dormant_enable", S_IRUGO | S_IWUSR,
				 dent_rhea_pm_root_dir, NULL,
				 &dormant_enable_fops))
		return -ENOMEM;

	return 0;
}
コード例 #17
0
ファイル: cdc.c プロジェクト: alexey6600/mm_sony_tetra_3.14
static int cdc_dbg_init(struct cdc *cdc_info)
{
	int i;
	char buf[20];
	cdc_info->cdc_dir = debugfs_create_dir("cdc", 0);

	if (!cdc_info->cdc_dir)
		return -EINVAL;

	for (i = 0; i < cdc_info->nr_cpus; i++) {
		sprintf(buf, "cpu%d_status", i);
		if (!debugfs_create_file(buf,
				S_IRUSR, cdc_info->cdc_dir, (void *)i,
				&cdc_dbg_get_status_ops))
			goto err;
	}
	if (!debugfs_create_u32("dbg_mask", S_IRUSR | S_IWUSR,
		cdc_info->cdc_dir, (u32 *)dbg_mask))
			goto err;

	if (!debugfs_create_file("dbg_bus",
			S_IRUSR | S_IWUSR , cdc_info->cdc_dir, NULL,
			&cdc_dbg_bus_ops))
		goto err;
	return 0;
err:
	debugfs_remove_recursive(cdc_info->cdc_dir);
	return -EINVAL;
}
コード例 #18
0
ファイル: debugfs.c プロジェクト: 3null/linux
/**
 * wil6210_debugfs_init_offset - create set of debugfs files
 * @wil - driver's context, used for printing
 * @dbg - directory on the debugfs, where files will be created
 * @base - base address used in address calculation
 * @tbl - table with file descriptions. Should be terminated with empty element.
 *
 * Creates files accordingly to the @tbl.
 */
static void wil6210_debugfs_init_offset(struct wil6210_priv *wil,
					struct dentry *dbg, void *base,
					const struct dbg_off * const tbl)
{
	int i;

	for (i = 0; tbl[i].name; i++) {
		struct dentry *f;

		switch (tbl[i].type) {
		case doff_u32:
			f = debugfs_create_u32(tbl[i].name, tbl[i].mode, dbg,
					       base + tbl[i].off);
			break;
		case doff_x32:
			f = debugfs_create_x32(tbl[i].name, tbl[i].mode, dbg,
					       base + tbl[i].off);
			break;
		case doff_ulong:
			f = wil_debugfs_create_ulong(tbl[i].name, tbl[i].mode,
						     dbg, base + tbl[i].off);
			break;
		case doff_io32:
			f = wil_debugfs_create_iomem_x32(tbl[i].name,
							 tbl[i].mode, dbg,
							 base + tbl[i].off);
			break;
		default:
			f = ERR_PTR(-EINVAL);
		}
		if (IS_ERR_OR_NULL(f))
			wil_err(wil, "Create file \"%s\": err %ld\n",
				tbl[i].name, PTR_ERR(f));
	}
}
コード例 #19
0
ファイル: ccmni.c プロジェクト: John677/Kernal_k3note
/* ccmni debug sys file create */
int ccmni_debug_file_init(int md_id)
{
	int result = -1;
	char fname[16];
	struct dentry *dentry1, *dentry2, *dentry3;

	CCMNI_INF_MSG(md_id, "ccmni_debug_file_init\n");

	dentry1 = debugfs_create_dir("ccmni", NULL);
	if (!dentry1) {
		CCMNI_ERR_MSG(md_id, "create /proc/ccmni fail\n");
		return -ENOENT;
	}

	snprintf(fname, 16, "md%d", (md_id+1));

	dentry2 = debugfs_create_dir(fname, dentry1);
	if (!dentry2) {
		CCMNI_ERR_MSG(md_id, "create /proc/ccmni/md%d fail\n", (md_id+1));
		return -ENOENT;
	}

	dentry3 = debugfs_create_u32("debug_level", 0600, dentry2, &ccmni_debug_level);
	result = PTR_ERR(dentry3);
	if (IS_ERR(dentry3) && result != -ENODEV) {
		CCMNI_ERR_MSG(md_id, "create /proc/ccmni/md%d/debug_level fail: %d\n", md_id, result);
		return -ENOENT;
	}

	return 0;
}
コード例 #20
0
static int ufs_test_debugfs_init(void)
{
	struct dentry *utils_root, *tests_root;
	int ret = 0;

	utils_root = test_iosched_get_debugfs_utils_root();
	tests_root = test_iosched_get_debugfs_tests_root();

	utd->test_list = kmalloc(sizeof(struct dentry *) * NUM_TESTS,
			GFP_KERNEL);
	if (!utd->test_list) {
		pr_err("%s: failed to allocate tests dentrys", __func__);
		return -ENODEV;
	}

	if (!utils_root || !tests_root) {
		pr_err("%s: Failed to create debugfs root.", __func__);
		ret = -EINVAL;
		goto exit_err;
	}

	utd->random_test_seed_dentry = debugfs_create_u32("random_test_seed",
			S_IRUGO | S_IWUGO, utils_root, &utd->random_test_seed);

	if (!utd->random_test_seed_dentry) {
		pr_err("%s: Could not create debugfs random_test_seed.",
				__func__);
		ret = -ENOMEM;
		goto exit_err;
	}

	ret = add_test(utd, write_read_test, WRITE_READ_TEST);
	if (ret)
		goto exit_err;
	ret = add_test(utd, long_sequential_read, LONG_SEQUENTIAL_READ);
	if (ret)
		goto exit_err;
	ret = add_test(utd, long_sequential_write, LONG_SEQUENTIAL_WRITE);
	if (ret)
		goto exit_err;
	ret = add_test(utd, long_sequential_mixed, LONG_SEQUENTIAL_MIXED);
	if (ret)
		goto exit_err;
	add_test(utd, multi_query, MULTI_QUERY);
	if (ret)
		goto exit_err;
	add_test(utd, parallel_read_and_write, PARALLEL_READ_AND_WRITE);
	if (ret)
		goto exit_err;
	add_test(utd, lun_depth, LUN_DEPTH);
	if (ret)
		goto exit_err;

	goto exit;

exit_err:
	ufs_test_debugfs_cleanup();
exit:
	return ret;
}
コード例 #21
0
static int setup_debugfs(void)
{
	int i;
	usecase_dir = debugfs_create_dir("usecase", NULL);

	if (IS_ERR_OR_NULL(usecase_dir))
		return -EINVAL;

	for (i = 0; i < ARRAY_SIZE(debug_entry); i++) {
		if (IS_ERR_OR_NULL(debugfs_create_file(debug_entry[i].name,
						       S_IWUSR | S_IWGRP | S_IRUGO,
						       usecase_dir,
						       NULL,
						       debug_entry[i].fops)))
			goto fail;
	}

	if (IS_ERR_OR_NULL(debugfs_create_u32("exit_irq_per_s",
					      S_IWUSR | S_IWGRP | S_IRUGO, usecase_dir,
					      &exit_irq_per_s)))
		goto fail;
	return 0;
fail:
	debugfs_remove_recursive(usecase_dir);
	return -EINVAL;
}
コード例 #22
0
static int test_create_debugfs(void)
{
	struct dentry *root = g_ts_data.dbg_root;
	struct dentry *dir;
	struct dentry *dent;
	int i;
	int error = -EINVAL;

	if(!root){
		TS_LOG_ERR("g_ts_data dont have dbg_root\n");
		goto out;
	}

	dir = debugfs_create_dir("test_dir", root);
	if (!dir) {
		TS_LOG_ERR("failed to create test_dir directory\n");
		goto out;
	}
	
	for(i = 0; i<ARRAY_SIZE(g_test_items); i++){
		dent = debugfs_create_u32(g_test_items[i].item_name, S_IRUGO | S_IWUSR, dir, &g_test_items[i].item_switch); 
		if (!dent) {
			TS_LOG_ERR("failed to create %s file\n", g_test_items[i].item_name);
			debugfs_remove_recursive(dir);
			break;
		}
	}

	if(i==ARRAY_SIZE(g_test_items))
		error = NO_ERR;
	
out:
	return error;
}
コード例 #23
0
int __init g2d_debug_init(void)
{
    struct dentry *g2d_debugfs_dir = NULL;

    g2d_debugfs_dir = debugfs_create_dir("g2d", NULL);

    if (ERR_PTR(-ENODEV) == g2d_debugfs_dir) {
        printk("debugfs_create_dir create dir fail! \n ");
        return -EINVAL;
    }
    debugfs_create_u32("powerdown", 0664, g2d_debugfs_dir, &(g2dPoweroffstatus));
    debugfs_create_u32("startfreq", 0444, g2d_debugfs_dir, &(g2d_start_freq));
    debugfs_create_u32("lockstate", 0444, g2d_debugfs_dir, &(g2d_lock_state));
    debugfs_create_u32("currentfreq", 0444, g2d_debugfs_dir, &(g_g2d_current_freq));
    return 0;
}
コード例 #24
0
ファイル: unaligned.c プロジェクト: 24hours/linux
static int __init debugfs_unaligned(void)
{
	struct dentry *d;

	if (!mips_debugfs_dir)
		return -ENODEV;
	d = debugfs_create_u32("unaligned_instructions", S_IRUGO,
			       mips_debugfs_dir, &unaligned_instructions);
	if (!d)
		return -ENOMEM;
	d = debugfs_create_u32("unaligned_action", S_IRUGO | S_IWUSR,
			       mips_debugfs_dir, &unaligned_action);
	if (!d)
		return -ENOMEM;
	return 0;
}
コード例 #25
0
void adreno_debugfs_init(struct kgsl_device *device)
{
	struct adreno_device *adreno_dev = ADRENO_DEVICE(device);

	if (!device->d_debugfs || IS_ERR(device->d_debugfs))
		return;

	debugfs_create_file("ib_dump",  0600, device->d_debugfs, device,
			    &kgsl_ib_dump_fops);
	debugfs_create_file("istore",   0400, device->d_debugfs, device,
			    &kgsl_istore_fops);
	debugfs_create_file("sx_debug", 0400, device->d_debugfs, device,
			    &kgsl_sx_debug_fops);
	debugfs_create_file("cp_debug", 0400, device->d_debugfs, device,
			    &kgsl_cp_debug_fops);
	debugfs_create_file("mh_debug", 0400, device->d_debugfs, device,
			    &kgsl_mh_debug_fops);
	debugfs_create_file("cff_dump", 0644, device->d_debugfs, device,
			    &kgsl_cff_dump_enable_fops);
	debugfs_create_u32("wait_timeout", 0644, device->d_debugfs,
		&adreno_dev->wait_timeout);

	/* Create post mortem control files */

	pm_d_debugfs = debugfs_create_dir("postmortem", device->d_debugfs);

	if (IS_ERR(pm_d_debugfs))
		return;

	debugfs_create_file("dump",  0600, pm_d_debugfs, device,
			    &pm_dump_fops);
	debugfs_create_file("regs_enabled", 0644, pm_d_debugfs, device,
			    &pm_regs_enabled_fops);
}
コード例 #26
0
ファイル: ufs_test.c プロジェクト: MattCrystal/ballin-robot
static int ufs_test_debugfs_init(void)
{
	struct dentry *utils_root, *tests_root;

	utils_root = test_iosched_get_debugfs_utils_root();
	tests_root = test_iosched_get_debugfs_tests_root();

	if (!utils_root || !tests_root) {
		test_pr_err("%s: Failed to create debugfs root.", __func__);
		return -EINVAL;
	}

	utd->debug.random_test_seed = debugfs_create_u32("random_test_seed",
			S_IRUGO | S_IWUGO, utils_root, &utd->random_test_seed);

	if (!utd->debug.random_test_seed) {
		test_pr_err("%s: Could not create debugfs random_test_seed.",
				__func__);
		return -ENOMEM;
	}

	utd->debug.write_read_test = debugfs_create_file("write_read_test",
					S_IRUGO | S_IWUGO, tests_root,
					NULL, &write_read_test_ops);

	if (!utd->debug.write_read_test) {
		debugfs_remove(utd->debug.random_test_seed);
		test_pr_err("%s: Could not create debugfs write_read_test.",
				__func__);
		return -ENOMEM;
	}

	return 0;
}
コード例 #27
0
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;

#ifdef CONFIG_MMC_CLKGATE
	if (!debugfs_create_u32("clk_delay", (S_IRUSR | S_IWUSR),
				root, &host->clk_delay))
		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");
}
コード例 #28
0
int init_module(void)
{
	dir = debugfs_create_dir("eudyptula", NULL);
	if (IS_ERR(dir)) {
		pr_debug("task08: failed to create /sys/kernel/debug/eudyptula\n");
		return -ENODEV;
	}

	if (!debugfs_create_file("id", 0666, dir, NULL, &eudyptula_fops)) {
		pr_debug("task08: failed to create id file\n");
		return -ENODEV;
	}

	if (!debugfs_create_u32("jiffies", 0444, dir, (u32 *)&jiffies)) {
		pr_debug("task08: failed to create jiffies file\n");
		return -ENODEV;
	}

	if (!debugfs_create_file("foo", 0644, dir, NULL, &foo_fops)) {
		pr_debug("task08: failed to create foo file\n");
		return -ENODEV;
	}

	return 0;
}
コード例 #29
0
void adreno_debugfs_init(struct kgsl_device *device)
{
	struct adreno_device *adreno_dev = ADRENO_DEVICE(device);

	if (!device->d_debugfs || IS_ERR(device->d_debugfs))
		return;

	debugfs_create_file("cff_dump", 0644, device->d_debugfs, device,
			    &kgsl_cff_dump_enable_fops);
	debugfs_create_u32("wait_timeout", 0644, device->d_debugfs,
		&adreno_dev->wait_timeout);
	debugfs_create_u32("ib_check", 0644, device->d_debugfs,
			   &adreno_dev->ib_check_level);
	debugfs_create_file("active_cnt", 0444, device->d_debugfs, device,
			    &_active_count_fops);
}
コード例 #30
0
void vidc_debugfs_file_create(struct dentry *root, const char *name,
				u32 *var)
{
	struct dentry *vidc_debugfs_file =
	    debugfs_create_u32(name, S_IRUGO | S_IWUSR, root, var);
	if (!vidc_debugfs_file)
		ERR("%s(): Error creating/opening file %s\n", __func__, name);
}