void regmap_debugfs_init(struct regmap *map, const char *name)
{
if (name) {
map->debugfs_name = kasprintf(GFP_KERNEL, "%s-%s",
dev_name(map->dev), name);
name = map->debugfs_name;
} else {
name = dev_name(map->dev);
}
map->debugfs = debugfs_create_dir(name, regmap_debugfs_root);
if (!map->debugfs) {
dev_warn(map->dev, "Failed to create debugfs directory\n");
return;
}
debugfs_create_file("name", 0400, map->debugfs,
map, ®map_name_fops);
if (map->max_register) {
debugfs_create_file("registers", 0400, map->debugfs,
map, ®map_map_fops);
debugfs_create_file("access", 0400, map->debugfs,
map, ®map_access_fops);
}
if (map->cache_type) {
debugfs_create_bool("cache_only", 0400, map->debugfs,
&map->cache_only);
debugfs_create_bool("cache_dirty", 0400, map->debugfs,
&map->cache_dirty);
debugfs_create_bool("cache_bypass", 0400, map->debugfs,
&map->cache_bypass);
}
}
void regmap_debugfs_init(struct regmap *map)
{
map->debugfs = debugfs_create_dir(dev_name(map->dev),
regmap_debugfs_root);
if (!map->debugfs) {
dev_warn(map->dev, "Failed to create debugfs directory\n");
return;
}
debugfs_create_file("name", 0400, map->debugfs,
map, ®map_name_fops);
if (map->max_register) {
debugfs_create_file("registers", 0400, map->debugfs,
map, ®map_map_fops);
debugfs_create_file("access", 0400, map->debugfs,
map, ®map_access_fops);
}
if (map->cache_type) {
debugfs_create_bool("cache_only", 0400, map->debugfs,
&map->cache_only);
debugfs_create_bool("cache_dirty", 0400, map->debugfs,
&map->cache_dirty);
debugfs_create_bool("cache_bypass", 0400, map->debugfs,
&map->cache_bypass);
}
}
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);
}
int mdss_panel_debugfs_fbc_setup(struct mdss_panel_debugfs_info *debugfs_info,
struct mdss_panel_info *panel_info, struct dentry *parent)
{
struct dentry *fbc_root;
fbc_root = debugfs_create_dir("fbc", parent);
if (IS_ERR_OR_NULL(fbc_root)) {
pr_err("Debugfs create fbc dir failed with error: %ld\n",
PTR_ERR(fbc_root));
return -ENODEV;
}
debugfs_create_bool("enable", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.enabled);
debugfs_create_u32("bpp", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.target_bpp);
debugfs_create_u32("packing", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.comp_mode);
debugfs_create_bool("quant_err", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.qerr_enable);
debugfs_create_u32("bias", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.cd_bias);
debugfs_create_bool("pat_mode", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.pat_enable);
debugfs_create_bool("vlc_mode", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.vlc_enable);
debugfs_create_bool("bflc_mode", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.bflc_enable);
debugfs_create_u32("hline_budget", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.line_x_budget);
debugfs_create_u32("budget_ctrl", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.block_x_budget);
debugfs_create_u32("block_budget", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.block_budget);
debugfs_create_u32("lossless_thd", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.lossless_mode_thd);
debugfs_create_u32("lossy_thd", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.lossy_mode_thd);
debugfs_create_u32("rgb_thd", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.lossy_rgb_thd);
debugfs_create_u32("lossy_mode_idx", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.lossy_mode_idx);
debugfs_create_u32("slice_height", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.slice_height);
debugfs_create_u32("pred_mode", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.pred_mode);
debugfs_create_u32("enc_mode", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.enc_mode);
debugfs_create_u32("max_pred_err", 0644, fbc_root,
(u32 *)&debugfs_info->fbc.max_pred_err);
debugfs_info->fbc = panel_info->fbc;
return 0;
}
void regmap_debugfs_init(struct regmap *map, const char *name)
{
struct rb_node *next;
struct regmap_range_node *range_node;
if (name) {
map->debugfs_name = kasprintf(GFP_KERNEL, "%s-%s",
dev_name(map->dev), name);
name = map->debugfs_name;
} else {
name = dev_name(map->dev);
}
map->debugfs = debugfs_create_dir(name, regmap_debugfs_root);
if (!map->debugfs) {
dev_warn(map->dev, "Failed to create debugfs directory\n");
return;
}
debugfs_create_file("name", 0400, map->debugfs,
map, ®map_name_fops);
if (map->max_register) {
debugfs_create_file("registers", 0400, map->debugfs,
map, ®map_map_fops);
debugfs_create_file("access", 0400, map->debugfs,
map, ®map_access_fops);
}
if (map->cache_type) {
debugfs_create_bool("cache_only", 0400, map->debugfs,
&map->cache_only);
debugfs_create_bool("cache_dirty", 0400, map->debugfs,
&map->cache_dirty);
debugfs_create_bool("cache_bypass", 0400, map->debugfs,
&map->cache_bypass);
}
next = rb_first(&map->range_tree);
while (next) {
range_node = rb_entry(next, struct regmap_range_node, node);
if (range_node->name)
debugfs_create_file(range_node->name, 0400,
map->debugfs, range_node,
®map_range_fops);
next = rb_next(&range_node->node);
}
}
void SystraceCreateFS(void)
{
struct dentry *capture_sgx_hwperfdata_ret;
pvrdir_ret = debugfs_create_dir("pvr", NULL);
capture_sgx_hwperfdata_ret = debugfs_create_bool("gpu_tracing_on", S_IFREG | S_IRUGO | S_IWUSR, pvrdir_ret, &capture_hwperfdata);
}
static int iTCO_wdt_probe(struct platform_device *pdev)
{
int ret = 0;
spin_lock_init(&iTCO_wdt_private.io_lock);
ret = iTCO_wdt_init(pdev);
if (ret)
return ret;
#ifdef CONFIG_DEBUG_FS
iTCO_debugfs_dir = debugfs_create_dir("iTCO", NULL);
debugfs_create_file("timeleft", S_IRUSR,
iTCO_debugfs_dir, NULL, &tl_fops);
debugfs_create_file("reset_type", S_IRUSR | S_IWUSR,
iTCO_debugfs_dir, NULL, &iTCO_wdt_reset_type_fops);
debugfs_create_file("trigger", S_IWUSR,
iTCO_debugfs_dir, NULL, &iTCO_wdt_trigger_fops);
debugfs_create_bool("panic_reboot_notifier", S_IRUSR | S_IWUSR,
iTCO_debugfs_dir,
(u32 *)&iTCO_wdt_private.panic_reboot_notifier);
#endif /* CONFIG_DEBUG_FS */
create_watchdog_sysfs_files();
return ret;
}
static void qca_debugfs_init(struct hci_dev *hdev)
{
struct hci_uart *hu = hci_get_drvdata(hdev);
struct qca_data *qca = hu->priv;
struct dentry *ibs_dir;
umode_t mode;
if (!hdev->debugfs)
return;
ibs_dir = debugfs_create_dir("ibs", hdev->debugfs);
/* read only */
mode = S_IRUGO;
debugfs_create_u8("tx_ibs_state", mode, ibs_dir, &qca->tx_ibs_state);
debugfs_create_u8("rx_ibs_state", mode, ibs_dir, &qca->rx_ibs_state);
debugfs_create_u64("ibs_sent_sleeps", mode, ibs_dir,
&qca->ibs_sent_slps);
debugfs_create_u64("ibs_sent_wakes", mode, ibs_dir,
&qca->ibs_sent_wakes);
debugfs_create_u64("ibs_sent_wake_acks", mode, ibs_dir,
&qca->ibs_sent_wacks);
debugfs_create_u64("ibs_recv_sleeps", mode, ibs_dir,
&qca->ibs_recv_slps);
debugfs_create_u64("ibs_recv_wakes", mode, ibs_dir,
&qca->ibs_recv_wakes);
debugfs_create_u64("ibs_recv_wake_acks", mode, ibs_dir,
&qca->ibs_recv_wacks);
debugfs_create_bool("tx_vote", mode, ibs_dir, &qca->tx_vote);
debugfs_create_u64("tx_votes_on", mode, ibs_dir, &qca->tx_votes_on);
debugfs_create_u64("tx_votes_off", mode, ibs_dir, &qca->tx_votes_off);
debugfs_create_bool("rx_vote", mode, ibs_dir, &qca->rx_vote);
debugfs_create_u64("rx_votes_on", mode, ibs_dir, &qca->rx_votes_on);
debugfs_create_u64("rx_votes_off", mode, ibs_dir, &qca->rx_votes_off);
debugfs_create_u64("votes_on", mode, ibs_dir, &qca->votes_on);
debugfs_create_u64("votes_off", mode, ibs_dir, &qca->votes_off);
debugfs_create_u32("vote_on_ms", mode, ibs_dir, &qca->vote_on_ms);
debugfs_create_u32("vote_off_ms", mode, ibs_dir, &qca->vote_off_ms);
/* read/write */
mode = S_IRUGO | S_IWUSR;
debugfs_create_u32("wake_retrans", mode, ibs_dir, &qca->wake_retrans);
debugfs_create_u32("tx_idle_delay", mode, ibs_dir,
&qca->tx_idle_delay);
}
/*
* snic_trc_debugfs_init : creates trace/tracing_enable files for trace
* under debugfs
*/
void snic_trc_debugfs_init(void)
{
snic_glob->trc.trc_enable = debugfs_create_bool("tracing_enable",
S_IFREG | S_IRUGO | S_IWUSR,
snic_glob->trc_root,
&snic_glob->trc.enable);
snic_glob->trc.trc_file = debugfs_create_file("trace",
S_IFREG | S_IRUGO | S_IWUSR,
snic_glob->trc_root, NULL,
&snic_trc_fops);
}
static int __init failslab_debugfs_init(void)
{
struct dentry *dir;
umode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
dir = fault_create_debugfs_attr("failslab", NULL, &failslab.attr);
if (IS_ERR(dir))
return PTR_ERR(dir);
if (!debugfs_create_bool("ignore-gfp-wait", mode, dir,
&failslab.ignore_gfp_reclaim))
goto fail;
if (!debugfs_create_bool("cache-filter", mode, dir,
&failslab.cache_filter))
goto fail;
return 0;
fail:
debugfs_remove_recursive(dir);
return -ENOMEM;
}
int ath10k_debug_create(struct ath10k *ar)
{
ar->debug.debugfs_phy = debugfs_create_dir("ath10k",
ar->hw->wiphy->debugfsdir);
if (!ar->debug.debugfs_phy)
return -ENOMEM;
INIT_DELAYED_WORK(&ar->debug.htt_stats_dwork,
ath10k_debug_htt_stats_dwork);
init_completion(&ar->debug.event_stats_compl);
debugfs_create_file("fw_stats", S_IRUSR, ar->debug.debugfs_phy, ar,
&fops_fw_stats);
debugfs_create_file("wmi_services", S_IRUSR, ar->debug.debugfs_phy, ar,
&fops_wmi_services);
debugfs_create_file("simulate_fw_crash", S_IRUSR, ar->debug.debugfs_phy,
ar, &fops_simulate_fw_crash);
debugfs_create_file("chip_id", S_IRUSR, ar->debug.debugfs_phy,
ar, &fops_chip_id);
debugfs_create_file("htt_stats_mask", S_IRUSR, ar->debug.debugfs_phy,
ar, &fops_htt_stats_mask);
debugfs_create_file("htt_max_amsdu_ampdu", S_IRUSR | S_IWUSR,
ar->debug.debugfs_phy, ar,
&fops_htt_max_amsdu_ampdu);
debugfs_create_file("fw_dbglog", S_IRUSR, ar->debug.debugfs_phy,
ar, &fops_fw_dbglog);
if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
debugfs_create_file("dfs_simulate_radar", S_IWUSR,
ar->debug.debugfs_phy, ar,
&fops_simulate_radar);
debugfs_create_bool("dfs_block_radar_events", S_IWUSR,
ar->debug.debugfs_phy,
&ar->dfs_block_radar_events);
debugfs_create_file("dfs_stats", S_IRUSR,
ar->debug.debugfs_phy, ar,
&fops_dfs_stats);
}
return 0;
}
void mt7603_init_debugfs(struct mt7603_dev *dev)
{
struct dentry *dir;
dir = mt76_register_debugfs(&dev->mt76);
if (!dir)
return;
debugfs_create_u32("reset_test", 0600, dir, &dev->reset_test);
debugfs_create_devm_seqfile(dev->mt76.dev, "reset", dir,
mt7603_reset_read);
debugfs_create_devm_seqfile(dev->mt76.dev, "radio", dir,
mt7603_radio_read);
debugfs_create_bool("dynamic_sensitivity", 0600, dir,
&dev->dynamic_sensitivity);
}
static int edac_create_debug_nodes(struct mem_ctl_info *mci)
{
struct dentry *d, *parent;
char name[80];
int i;
if (!edac_debugfs)
return -ENODEV;
d = debugfs_create_dir(mci->dev.kobj.name, edac_debugfs);
if (!d)
return -ENOMEM;
parent = d;
for (i = 0; i < mci->n_layers; i++) {
sprintf(name, "fake_inject_%s",
edac_layer_name[mci->layers[i].type]);
d = debugfs_create_u8(name, S_IRUGO | S_IWUSR, parent,
&mci->fake_inject_layer[i]);
if (!d)
goto nomem;
}
d = debugfs_create_bool("fake_inject_ue", S_IRUGO | S_IWUSR, parent,
&mci->fake_inject_ue);
if (!d)
goto nomem;
d = debugfs_create_u16("fake_inject_count", S_IRUGO | S_IWUSR, parent,
&mci->fake_inject_count);
if (!d)
goto nomem;
d = debugfs_create_file("fake_inject", S_IWUSR, parent,
&mci->dev,
&debug_fake_inject_fops);
if (!d)
goto nomem;
mci->debugfs = parent;
return 0;
nomem:
debugfs_remove(mci->debugfs);
return -ENOMEM;
}
static int __init simon_debugfs_init_domain(struct dentry *dir,
struct tegra_simon_grader *grader)
{
struct dentry *d;
d = debugfs_create_dir(grader->domain_name, dir);
if (!d)
return -ENOMEM;
if (!debugfs_create_file("grade", S_IWUSR | S_IRUGO, d,
(void *)grader, &grade_fops))
return -ENOMEM;
if (!debugfs_create_bool("grading_stopped", S_IRUGO, d,
(u32 *)&grader->stop_grading))
return -ENOMEM;
return 0;
}
void mt76x02_init_debugfs(struct mt76x02_dev *dev)
{
struct dentry *dir;
dir = mt76_register_debugfs(&dev->mt76);
if (!dir)
return;
debugfs_create_u8("temperature", 0400, dir, &dev->cal.temp);
debugfs_create_bool("tpc", 0600, dir, &dev->enable_tpc);
debugfs_create_file("ampdu_stat", 0400, dir, dev, &fops_ampdu_stat);
debugfs_create_file("dfs_stats", 0400, dir, dev, &fops_dfs_stat);
debugfs_create_devm_seqfile(dev->mt76.dev, "txpower", dir,
read_txpower);
debugfs_create_devm_seqfile(dev->mt76.dev, "agc", dir, read_agc);
debugfs_create_u32("tx_hang_reset", 0400, dir, &dev->tx_hang_reset);
}
/*
* snic_trc_debugfs_init : creates trace/tracing_enable files for trace
* under debugfs
*/
int
snic_trc_debugfs_init(void)
{
struct dentry *de = NULL;
int ret = -1;
if (!snic_glob->trc_root) {
SNIC_ERR("Debugfs root directory for snic doesn't exist.\n");
return ret;
}
de = debugfs_create_bool("tracing_enable",
S_IFREG | S_IRUGO | S_IWUSR,
snic_glob->trc_root,
&snic_glob->trc.enable);
if (!de) {
SNIC_ERR("Can't create trace_enable file.\n");
return ret;
}
snic_glob->trc.trc_enable = de;
de = debugfs_create_file("trace",
S_IFREG | S_IRUGO | S_IWUSR,
snic_glob->trc_root,
NULL,
&snic_trc_fops);
if (!de) {
SNIC_ERR("Cannot create trace file.\n");
return ret;
}
snic_glob->trc.trc_file = de;
ret = 0;
return ret;
} /* end of snic_trc_debugfs_init */
struct dentry *esp_dump_var(const char *name, struct dentry *parent, void *value, esp_type type) {
struct dentry *rc = NULL;
umode_t mode = 0644;
if(!esp_debugfs_root)
return NULL;
if(!parent)
parent = esp_debugfs_root;
switch(type) {
case ESP_U8:
rc = debugfs_create_u8(name, mode, parent, (u8*)value);
break;
case ESP_U16:
rc = debugfs_create_u16(name, mode, parent, (u16*)value);
break;
case ESP_U32:
rc = debugfs_create_u32(name, mode, parent, (u32*)value);
break;
case ESP_U64:
rc = debugfs_create_u64(name, mode, parent, (u64*)value);
break;
case ESP_BOOL:
rc = debugfs_create_bool(name, mode, parent, (u32*)value);
break;
default: //32
rc = debugfs_create_u32(name, mode, parent, (u32*)value);
}
if (!rc)
goto Fail;
else
return rc;
Fail:
debugfs_remove_recursive(esp_debugfs_root);
esp_debugfs_root = NULL;
esp_dbg(ESP_DBG_ERROR, "%s failed, debugfs root removed; var name: %s\n", __FUNCTION__, name);
return NULL;
}
struct dentry *mt76_register_debugfs(struct mt76_dev *dev)
{
struct dentry *dir;
dir = debugfs_create_dir("mt76", dev->hw->wiphy->debugfsdir);
if (!dir)
return NULL;
debugfs_create_u8("led_pin", 0600, dir, &dev->led_pin);
debugfs_create_bool("led_active_low", 0600, dir, &dev->led_al);
debugfs_create_u32("regidx", 0600, dir, &dev->debugfs_reg);
debugfs_create_file_unsafe("regval", 0600, dir, dev,
&fops_regval);
debugfs_create_blob("eeprom", 0400, dir, &dev->eeprom);
if (dev->otp.data)
debugfs_create_blob("otp", 0400, dir, &dev->otp);
debugfs_create_devm_seqfile(dev->dev, "queues", dir, mt76_queues_read);
debugfs_create_devm_seqfile(dev->dev, "rate_txpower", dir,
mt76_read_rate_txpower);
return dir;
}
static int setup_debugfs(struct driver_ctl_data *ctl_data)
{
struct rmi_device *rmi_dev = ctl_data->rmi_dev;
struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
struct rmi_transport_info *info = &rmi_dev->xport->info;
int retval = 0;
if (!rmi_dev->debugfs_root)
return 0;
if (IS_ENABLED(CONFIG_RMI4_SPI) && !strncmp("spi", info->proto, 3)) {
ctl_data->debugfs_delay = debugfs_create_file("delay",
RMI_RW_ATTR, rmi_dev->debugfs_root, rmi_dev,
&delay_fops);
if (!ctl_data->debugfs_delay || IS_ERR(ctl_data->debugfs_delay)) {
dev_warn(&rmi_dev->dev, "Failed to create debugfs delay.\n");
ctl_data->debugfs_delay = NULL;
}
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
if (!debugfs_create_u32_array("transport_stats", RMI_RO_ATTR,
rmi_dev->debugfs_root, (u32 *)&info->tx_count, 6))
dev_warn(&rmi_dev->dev,
"Failed to create debugfs transport_stats\n");
#endif
if (debugfs_create_bool("irq_debug", RMI_RW_ATTR, rmi_dev->debugfs_root,
&data->irq_debug))
dev_warn(&rmi_dev->dev, "Failed to create debugfs irq_debug.\n");
if (!debugfs_create_u32("attn_count", RMI_RO_ATTR,
rmi_dev->debugfs_root, &data->attn_count))
dev_warn(&rmi_dev->dev, "Failed to create debugfs attn_count.\n");
return retval;
}
static int __init failslab_debugfs_init(void)
{
mode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
struct dentry *dir;
int err;
err = init_fault_attr_dentries(&failslab.attr, "failslab");
if (err)
return err;
dir = failslab.attr.dentries.dir;
failslab.ignore_gfp_wait_file =
debugfs_create_bool("ignore-gfp-wait", mode, dir,
&failslab.ignore_gfp_wait);
if (!failslab.ignore_gfp_wait_file) {
err = -ENOMEM;
debugfs_remove(failslab.ignore_gfp_wait_file);
cleanup_fault_attr_dentries(&failslab.attr);
}
return err;
}
static int acpi_ec_add_debugfs(struct acpi_ec *ec, unsigned int ec_device_count)
{
struct dentry *dev_dir;
char name[64];
umode_t mode = 0400;
if (ec_device_count == 0) {
acpi_ec_debugfs_dir = debugfs_create_dir("ec", NULL);
if (!acpi_ec_debugfs_dir)
return -ENOMEM;
}
sprintf(name, "ec%u", ec_device_count);
dev_dir = debugfs_create_dir(name, acpi_ec_debugfs_dir);
if (!dev_dir) {
if (ec_device_count != 0)
goto error;
return -ENOMEM;
}
if (!debugfs_create_x32("gpe", 0444, dev_dir, (u32 *)&first_ec->gpe))
goto error;
if (!debugfs_create_bool("use_global_lock", 0444, dev_dir,
&first_ec->global_lock))
goto error;
if (write_support)
mode = 0600;
if (!debugfs_create_file("io", mode, dev_dir, ec, &acpi_ec_io_ops))
goto error;
return 0;
error:
debugfs_remove_recursive(acpi_ec_debugfs_dir);
return -ENOMEM;
}
static int iTCO_wdt_probe(struct platform_device *dev)
{
int ret = -ENODEV;
int found = 0;
struct pci_dev *pdev = NULL;
const struct pci_device_id *ent;
spin_lock_init(&iTCO_wdt_private.io_lock);
for_each_pci_dev(pdev) {
ent = pci_match_id(iTCO_wdt_pci_tbl, pdev);
if (ent) {
found++;
ret = iTCO_wdt_init(pdev, ent, dev);
#ifdef CONFIG_DEBUG_FS
iTCO_debugfs_dir = debugfs_create_dir("iTCO", NULL);
debugfs_create_file("timeleft", S_IRUSR,
iTCO_debugfs_dir, NULL, &tl_fops);
debugfs_create_file("reset_type", S_IRUSR | S_IWUSR,
iTCO_debugfs_dir, NULL, &iTCO_wdt_reset_type_fops);
debugfs_create_file("trigger", S_IWUSR,
iTCO_debugfs_dir, NULL, &iTCO_wdt_trigger_fops);
debugfs_create_bool("panic_reboot_notifier", S_IRUSR | S_IWUSR,
iTCO_debugfs_dir,
(u32 *)&iTCO_wdt_private.panic_reboot_notifier);
#endif /* CONFIG_DEBUG_FS */
if (!ret)
break;
}
}
if (!found)
pr_info("No device detected\n");
return ret;
}
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");
}
if (pdata->vdata->an_cdr_workaround) {
pfile = debugfs_create_bool("an_cdr_workaround", 0600,
pdata->xgbe_debugfs,
&pdata->debugfs_an_cdr_workaround);
if (!pfile)
netdev_err(pdata->netdev,
"debugfs_create_bool failed\n");
pfile = debugfs_create_bool("an_cdr_track_early", 0600,
pdata->xgbe_debugfs,
&pdata->debugfs_an_cdr_track_early);
if (!pfile)
netdev_err(pdata->netdev,
"debugfs_create_bool failed\n");
}
kfree(buf);
}
static int dp_debugfs_init(struct data_path *dp)
{
char buf[256];
char path[256];
dp->dentry = debugfs_create_dir(dp->name ? dp->name : "dp",
dp_debugfs_root_dir);
if (!dp->dentry)
return -ENOMEM;
snprintf(path, sizeof(path), "../../../%s",
dentry_path_raw(dp->rbctl->rbdir, buf, sizeof(buf)));
if (IS_ERR_OR_NULL(debugfs_create_symlink(
"shm", dp->dentry, path)))
goto error;
if (IS_ERR_OR_NULL(debugfs_create_file(
"tx_q", S_IRUGO, dp->dentry,
dp, &fops_tx_q)))
goto error;
if (IS_ERR_OR_NULL(debugfs_create_file(
"stat", S_IRUGO, dp->dentry,
dp, &fops_stat)))
goto error;
if (IS_ERR_OR_NULL(debugfs_create_file(
"wm", S_IRUGO | S_IWUSR, dp->dentry,
dp, &fops_wm)))
goto error;
if (IS_ERR_OR_NULL(debugfs_create_bool(
"enable_piggyback", S_IRUGO | S_IWUSR,
dp->dentry, &dp->enable_piggyback)))
goto error;
if (IS_ERR_OR_NULL(debugfs_create_bool(
"is_tx_stopped", S_IRUGO | S_IWUSR,
dp->dentry, &dp->is_tx_stopped)))
goto error;
if (IS_ERR_OR_NULL(debugfs_create_u32(
"tx_q_max_len", S_IRUGO | S_IWUSR,
dp->dentry, &dp->tx_q_max_len)))
goto error;
if (IS_ERR_OR_NULL(debugfs_create_u16(
"max_tx_shots", S_IRUGO | S_IWUSR,
dp->dentry, &dp->max_tx_shots)))
goto error;
if (IS_ERR_OR_NULL(debugfs_create_u16(
"max_rx_shots", S_IRUGO | S_IWUSR,
dp->dentry, &dp->max_rx_shots)))
goto error;
if (IS_ERR_OR_NULL(debugfs_create_u16(
"tx_sched_delay_in_ms", S_IRUGO | S_IWUSR,
dp->dentry, &dp->tx_sched_delay_in_ms)))
goto error;
if (IS_ERR_OR_NULL(debugfs_create_u16(
"tx_q_min_sched_len", S_IRUGO | S_IWUSR,
dp->dentry, &dp->tx_q_min_sched_len)))
goto error;
return 0;
error:
debugfs_remove_recursive(dp->dentry);
dp->dentry = NULL;
return -1;
}
int init_fault_attr_dentries(struct fault_attr *attr, const char *name)
{
mode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
struct dentry *dir;
memset(&attr->dentries, 0, sizeof(attr->dentries));
dir = debugfs_create_dir(name, NULL);
if (!dir)
goto fail;
attr->dentries.dir = dir;
attr->dentries.probability_file =
debugfs_create_ul("probability", mode, dir, &attr->probability);
attr->dentries.interval_file =
debugfs_create_ul("interval", mode, dir, &attr->interval);
attr->dentries.times_file =
debugfs_create_atomic_t("times", mode, dir, &attr->times);
attr->dentries.space_file =
debugfs_create_atomic_t("space", mode, dir, &attr->space);
attr->dentries.verbose_file =
debugfs_create_ul("verbose", mode, dir, &attr->verbose);
attr->dentries.task_filter_file = debugfs_create_bool("task-filter",
mode, dir, &attr->task_filter);
if (!attr->dentries.probability_file || !attr->dentries.interval_file ||
!attr->dentries.times_file || !attr->dentries.space_file ||
!attr->dentries.verbose_file || !attr->dentries.task_filter_file)
goto fail;
#ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
attr->dentries.stacktrace_depth_file =
debugfs_create_ul_MAX_STACK_TRACE_DEPTH(
"stacktrace-depth", mode, dir, &attr->stacktrace_depth);
attr->dentries.require_start_file =
debugfs_create_ul("require-start", mode, dir, &attr->require_start);
attr->dentries.require_end_file =
debugfs_create_ul("require-end", mode, dir, &attr->require_end);
attr->dentries.reject_start_file =
debugfs_create_ul("reject-start", mode, dir, &attr->reject_start);
attr->dentries.reject_end_file =
debugfs_create_ul("reject-end", mode, dir, &attr->reject_end);
if (!attr->dentries.stacktrace_depth_file ||
!attr->dentries.require_start_file ||
!attr->dentries.require_end_file ||
!attr->dentries.reject_start_file ||
!attr->dentries.reject_end_file)
goto fail;
#endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
return 0;
fail:
cleanup_fault_attr_dentries(attr);
return -ENOMEM;
}
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_cmn_spectral_init_debug(&sc->spec_priv, sc->debug.debugfs_phy);
debugfs_create_devm_seqfile(sc->dev, "dma", sc->debug.debugfs_phy,
read_file_dma);
debugfs_create_devm_seqfile(sc->dev, "interrupt", sc->debug.debugfs_phy,
read_file_interrupt);
debugfs_create_devm_seqfile(sc->dev, "xmit", sc->debug.debugfs_phy,
read_file_xmit);
debugfs_create_devm_seqfile(sc->dev, "queues", sc->debug.debugfs_phy,
read_file_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_devm_seqfile(sc->dev, "misc", sc->debug.debugfs_phy,
read_file_misc);
debugfs_create_devm_seqfile(sc->dev, "reset", sc->debug.debugfs_phy,
read_file_reset);
ath9k_cmn_debug_recv(sc->debug.debugfs_phy, &sc->debug.stats.rxstats);
ath9k_cmn_debug_phy_err(sc->debug.debugfs_phy, &sc->debug.stats.rxstats);
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_devm_seqfile(sc->dev, "dump_nfcal",
sc->debug.debugfs_phy,
read_file_dump_nfcal);
ath9k_cmn_debug_base_eeprom(sc->debug.debugfs_phy, sc->sc_ah);
ath9k_cmn_debug_modal_eeprom(sc->debug.debugfs_phy, sc->sc_ah);
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
#ifdef CPTCFG_ATH9K_WOW
debugfs_create_file("wow", S_IRUSR | S_IWUSR,
sc->debug.debugfs_phy, sc, &fops_wow);
#endif
#ifdef CPTCFG_ATH9K_DYNACK
debugfs_create_file("ack_to", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy,
sc, &fops_ackto);
#endif
debugfs_create_file("tpc", S_IRUSR | S_IWUSR,
sc->debug.debugfs_phy, sc, &fops_tpc);
return 0;
}
static void *rate_control_pid_alloc(struct ieee80211_local *local)
{
struct rc_pid_info *pinfo;
struct rc_pid_rateinfo *rinfo;
struct ieee80211_supported_band *sband;
int i, j, tmp;
bool s;
#ifdef CONFIG_MAC80211_DEBUGFS
struct rc_pid_debugfs_entries *de;
#endif
sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
pinfo = kmalloc(sizeof(*pinfo), GFP_ATOMIC);
if (!pinfo)
return NULL;
/* We can safely assume that sband won't change unless we get
* reinitialized. */
rinfo = kmalloc(sizeof(*rinfo) * sband->n_bitrates, GFP_ATOMIC);
if (!rinfo) {
kfree(pinfo);
return NULL;
}
/* Sort the rates. This is optimized for the most common case (i.e.
* almost-sorted CCK+OFDM rates). Kind of bubble-sort with reversed
* mapping too. */
for (i = 0; i < sband->n_bitrates; i++) {
rinfo[i].index = i;
rinfo[i].rev_index = i;
if (pinfo->fast_start)
rinfo[i].diff = 0;
else
rinfo[i].diff = i * pinfo->norm_offset;
}
for (i = 1; i < sband->n_bitrates; i++) {
s = 0;
for (j = 0; j < sband->n_bitrates - i; j++)
if (unlikely(sband->bitrates[rinfo[j].index].bitrate >
sband->bitrates[rinfo[j + 1].index].bitrate)) {
tmp = rinfo[j].index;
rinfo[j].index = rinfo[j + 1].index;
rinfo[j + 1].index = tmp;
rinfo[rinfo[j].index].rev_index = j;
rinfo[rinfo[j + 1].index].rev_index = j + 1;
s = 1;
}
if (!s)
break;
}
pinfo->target = RC_PID_TARGET_PF;
pinfo->sampling_period = RC_PID_INTERVAL;
pinfo->coeff_p = RC_PID_COEFF_P;
pinfo->coeff_i = RC_PID_COEFF_I;
pinfo->coeff_d = RC_PID_COEFF_D;
pinfo->smoothing_shift = RC_PID_SMOOTHING_SHIFT;
pinfo->sharpen_factor = RC_PID_SHARPENING_FACTOR;
pinfo->sharpen_duration = RC_PID_SHARPENING_DURATION;
pinfo->norm_offset = RC_PID_NORM_OFFSET;
pinfo->fast_start = RC_PID_FAST_START;
pinfo->rinfo = rinfo;
pinfo->oldrate = 0;
#ifdef CONFIG_MAC80211_DEBUGFS
de = &pinfo->dentries;
de->dir = debugfs_create_dir("rc80211_pid",
local->hw.wiphy->debugfsdir);
de->target = debugfs_create_u32("target_pf", S_IRUSR | S_IWUSR,
de->dir, &pinfo->target);
de->sampling_period = debugfs_create_u32("sampling_period",
S_IRUSR | S_IWUSR, de->dir,
&pinfo->sampling_period);
de->coeff_p = debugfs_create_u32("coeff_p", S_IRUSR | S_IWUSR,
de->dir, &pinfo->coeff_p);
de->coeff_i = debugfs_create_u32("coeff_i", S_IRUSR | S_IWUSR,
de->dir, &pinfo->coeff_i);
de->coeff_d = debugfs_create_u32("coeff_d", S_IRUSR | S_IWUSR,
de->dir, &pinfo->coeff_d);
de->smoothing_shift = debugfs_create_u32("smoothing_shift",
S_IRUSR | S_IWUSR, de->dir,
&pinfo->smoothing_shift);
de->sharpen_factor = debugfs_create_u32("sharpen_factor",
S_IRUSR | S_IWUSR, de->dir,
&pinfo->sharpen_factor);
de->sharpen_duration = debugfs_create_u32("sharpen_duration",
S_IRUSR | S_IWUSR, de->dir,
&pinfo->sharpen_duration);
de->norm_offset = debugfs_create_u32("norm_offset",
S_IRUSR | S_IWUSR, de->dir,
&pinfo->norm_offset);
de->fast_start = debugfs_create_bool("fast_start",
S_IRUSR | S_IWUSR, de->dir,
&pinfo->fast_start);
#endif
return pinfo;
}
void ux500_suspend_dbg_init(void)
{
struct dentry *suspend_dir;
struct dentry *file;
suspend_dir = debugfs_create_dir("suspend", NULL);
if (IS_ERR_OR_NULL(suspend_dir))
return;
file = debugfs_create_bool("sleep", S_IWUGO | S_IRUGO,
suspend_dir,
&sleep_enabled);
if (IS_ERR_OR_NULL(file))
goto error;
file = debugfs_create_bool("deepsleep", S_IWUGO | S_IRUGO,
suspend_dir,
&deepsleep_enabled);
if (IS_ERR_OR_NULL(file))
goto error;
file = debugfs_create_bool("enable", S_IWUGO | S_IRUGO,
suspend_dir,
&suspend_enabled);
if (IS_ERR_OR_NULL(file))
goto error;
file = debugfs_create_u32("count", S_IRUGO,
suspend_dir,
&suspend_count);
if (IS_ERR_OR_NULL(file))
goto error;
file = debugfs_create_u32("sleep_count", S_IRUGO,
suspend_dir,
&sleeps_done);
if (IS_ERR_OR_NULL(file))
goto error;
file = debugfs_create_u32("deepsleep_count", S_IRUGO,
suspend_dir,
&deepsleeps_done);
if (IS_ERR_OR_NULL(file))
goto error;
file = debugfs_create_u32("sleep_failed", S_IRUGO,
suspend_dir,
&sleeps_failed);
if (IS_ERR_OR_NULL(file))
goto error;
file = debugfs_create_u32("deepsleep_failed", S_IRUGO,
suspend_dir,
&deepsleeps_failed);
if (IS_ERR_OR_NULL(file))
goto error;
return;
error:
if (!IS_ERR_OR_NULL(suspend_dir))
debugfs_remove_recursive(suspend_dir);
}
int b2r2_debug_init(struct b2r2_control *cont)
{
int i;
if (!module_init) {
for (i = 0; i < B2R2_LOG_LEVEL_COUNT; i++)
b2r2_log_levels[i] = 0;
#if !defined(CONFIG_DYNAMIC_DEBUG) && defined(CONFIG_DEBUG_FS)
/*
* If dynamic debug is disabled we need some other way to
* control the log prints
*/
log_lvl_dir = debugfs_create_dir("b2r2_log", NULL);
/* No need to save the files,
* they will be removed recursively */
if (!IS_ERR_OR_NULL(log_lvl_dir)) {
(void)debugfs_create_bool("warnings", 0644, log_lvl_dir,
&b2r2_log_levels[B2R2_LOG_LEVEL_WARN]);
(void)debugfs_create_bool("info", 0644, log_lvl_dir,
&b2r2_log_levels[B2R2_LOG_LEVEL_INFO]);
(void)debugfs_create_bool("debug", 0644, log_lvl_dir,
&b2r2_log_levels[B2R2_LOG_LEVEL_DEBUG]);
(void)debugfs_create_bool("regdumps", 0644, log_lvl_dir,
&b2r2_log_levels[B2R2_LOG_LEVEL_REGDUMP]);
}
#elif defined(CONFIG_DYNAMIC_DEBUG)
/* log_lvl_dir is never used */
(void)log_lvl_dir;
#endif
module_init++;
}
if (!IS_ERR_OR_NULL(cont->debugfs_debug_root_dir)) {
/* No need to save the file,
* it will be removed recursively */
(void)debugfs_create_file("last_job", 0444,
cont->debugfs_debug_root_dir, cont,
&last_job_fops);
}
if (!IS_ERR_OR_NULL(cont->debugfs_debug_root_dir)) {
cont->dump.debugfs_root_dir =
debugfs_create_dir("dump",
cont->debugfs_debug_root_dir);
if (!IS_ERR_OR_NULL(cont->dump.debugfs_root_dir)) {
(void)debugfs_create_x32("src_filter", 0644,
cont->dump.debugfs_root_dir,
&cont->dump.src_filter);
(void)debugfs_create_x32("dst_filter", 0644,
cont->dump.debugfs_root_dir,
&cont->dump.dst_filter);
(void)debugfs_create_file("capture", 0444,
cont->dump.debugfs_root_dir,
cont, &capture_buffers_fops);
}
}
mutex_init(&cont->last_job_lock);
mutex_init(&cont->dump.lock);
return 0;
}
