static inline void debugfs_init(struct ser_device *ser, struct tty_struct *tty)
{
ser->debugfs_tty_dir =
debugfs_create_dir(tty->name, debugfsdir);
if (!IS_ERR(ser->debugfs_tty_dir)) {
debugfs_create_blob("last_tx_msg", S_IRUSR,
ser->debugfs_tty_dir,
&ser->tx_blob);
debugfs_create_blob("last_rx_msg", S_IRUSR,
ser->debugfs_tty_dir,
&ser->rx_blob);
debugfs_create_x32("ser_state", S_IRUSR,
ser->debugfs_tty_dir,
(u32 *)&ser->state);
debugfs_create_x8("tty_status", S_IRUSR,
ser->debugfs_tty_dir,
&ser->tty_status);
}
ser->tx_blob.data = ser->tx_data;
ser->tx_blob.size = 0;
ser->rx_blob.data = ser->rx_data;
ser->rx_blob.size = 0;
}
static int scom_debug_init_one(struct dentry *root, struct device_node *dn,
int i)
{
struct scom_debug_entry *ent;
struct dentry *dir;
ent = kzalloc(sizeof(*ent), GFP_KERNEL);
if (!ent)
return -ENOMEM;
ent->dn = of_node_get(dn);
ent->map = SCOM_MAP_INVALID;
spin_lock_init(&ent->lock);
snprintf(ent->name, 8, "scom%d", i);
ent->blob.data = dn->full_name;
ent->blob.size = strlen(dn->full_name);
dir = debugfs_create_dir(ent->name, root);
if (!dir) {
of_node_put(dn);
kfree(ent);
return -1;
}
debugfs_create_file("addr", 0600, dir, ent, &scom_addr_fops);
debugfs_create_file("value", 0600, dir, ent, &scom_val_fops);
debugfs_create_blob("path", 0400, dir, &ent->blob);
return 0;
}
static int __init demo_debugfs_init(void)
{
struct dentry *sub_dir, *p0_dentry, *p1_dentry, *p2_dentry;
demo_debugfs_root = debugfs_create_dir("debugfs-demo", NULL);
if (!demo_debugfs_root)
return -ENOENT;
p0_dentry = debugfs_create_u8("p0", 0644, demo_debugfs_root, &p0);
if (!p0_dentry)
goto Fail;
p1.data = (void *)str;
p1.size = strlen(str) + 1;
p1_dentry = debugfs_create_blob("p1", 0644, demo_debugfs_root, &p1);
if (!p1_dentry)
goto Fail;
sub_dir = debugfs_create_dir("subdir", demo_debugfs_root);
if (!sub_dir)
goto Fail;
p2_dentry = debugfs_create_file("p2", 0644, sub_dir, NULL, &p2_fops);
if (!p2_dentry)
goto Fail;
return 0;
Fail:
debugfs_remove_recursive(demo_debugfs_root);
demo_debugfs_root = NULL;
return -ENOENT;
}
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_u32("regidx", S_IRUSR | S_IWUSR, dir, &dev->debugfs_reg);
debugfs_create_file("regval", S_IRUSR | S_IWUSR, dir, dev, &fops_regval);
debugfs_create_blob("eeprom", S_IRUSR, dir, &dev->eeprom);
if (dev->otp.data)
debugfs_create_blob("otp", S_IRUSR, dir, &dev->otp);
debugfs_create_devm_seqfile(dev->dev, "queues", dir, mt76_queues_read);
return dir;
}
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_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;
}
int my_init(void)
{
int i;
int stats_size; /* size of our data */
int struct_size; /* size of the blob struct */
struct_size = sizeof(struct debugfs_blob_wrapper);
stats_size = SIZE * sizeof(u32);
/* get mem for data */
stats = kmalloc(stats_size, GFP_KERNEL);
if (stats == NULL) {
printk("Could not allocate mem for data\n");
return -ENOMEM;
}
/* fill datablob with dummy data */
for (i = 0; i < SIZE; i++)
stats[i] = i;
/* get mem for blob struct and init */
myblob = (struct debugfs_blob_wrapper *) kmalloc(struct_size, GFP_KERNEL);
if (myblob == NULL) {
printk("Could not allocate mem for blob\n");
kfree(stats);
return -ENOMEM;
}
/* only set data pointer and data size */
myblob->data = (void *) stats;
myblob->size = (unsigned long) stats_size;
/* create pseudo file under /sys/kernel/debug/ with name 'test' */
dfs = debugfs_create_blob("test", 0644, NULL, myblob);
if (dfs == NULL) {
printk("Could not create debugfs blob\n");
kfree(stats);
kfree(myblob);
return -EINVAL;
}
printk("DebugFS file created\n");
return 0;
}
static inline void dev_debugfs_add(struct mem_link_device *mld)
{
mld->dbgfs_dir = debugfs_create_dir("svnet", NULL);
mld->mem_dump_blob.data = mld->base;
mld->mem_dump_blob.size = mld->size;
debugfs_create_blob("mem_dump", S_IRUGO, mld->dbgfs_dir,
&mld->mem_dump_blob);
mld->dbgfs_frame = debugfs_create_file("frame", S_IRUGO,
mld->dbgfs_dir, mld, &dbgfs_frame_fops);
}
static int __init export_flat_device_tree(void)
{
struct dentry *d;
flat_dt_blob.data = initial_boot_params;
flat_dt_blob.size = initial_boot_params->totalsize;
d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR,
of_debugfs_root, &flat_dt_blob);
if (!d)
return 1;
return 0;
}
static void __init crashlog_copy(void)
{
if (crashlog_buf->magic != CRASHLOG_MAGIC)
return;
if (!crashlog_buf->len || crashlog_buf->len >
CRASHLOG_SIZE - sizeof(*crashlog_buf))
return;
crashlog_blob.size = crashlog_buf->len;
crashlog_blob.data = kmemdup(crashlog_buf->data,
crashlog_buf->len, GFP_KERNEL);
debugfs_create_blob("crashlog", 0700, NULL, &crashlog_blob);
}
static int __init of_flat_dt_debugfs_export_fdt(void)
{
struct dentry *d = debugfs_create_dir("device-tree", NULL);
if (!d)
return -ENOENT;
flat_dt_blob.data = initial_boot_params;
flat_dt_blob.size = fdt_totalsize(initial_boot_params);
d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR,
d, &flat_dt_blob);
if (!d)
return -ENOENT;
return 0;
}
static struct dentry *rt2x00debug_create_file_driver(const char *name,
struct rt2x00debug_intf
*intf,
struct debugfs_blob_wrapper
*blob)
{
char *data;
data = kzalloc(3 * PRINT_LINE_LEN_MAX, GFP_KERNEL);
if (!data)
return NULL;
blob->data = data;
data += sprintf(data, "driver: %s\n", DRIVER_NAME);
data += sprintf(data, "version: %s\n", DRIVER_VERSION);
data += sprintf(data, "compiled: %s %s\n", __DATE__, __TIME__);
blob->size = strlen(blob->data);
return debugfs_create_blob(name, S_IRUGO, intf->driver_folder, blob);
}
struct dentry *esp_dump_array(const char *name, struct dentry *parent, struct debugfs_blob_wrapper *blob) {
struct dentry * rc = NULL;
umode_t mode = 0644;
if(!esp_debugfs_root)
return NULL;
if(!parent)
parent = esp_debugfs_root;
rc = debugfs_create_blob(name, mode, parent, blob);
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;
}
static struct dentry *rt2x00debug_create_file_chipset(const char *name,
struct rt2x00debug_intf
*intf,
struct
debugfs_blob_wrapper
*blob)
{
const struct rt2x00debug *debug = intf->debug;
char *data;
data = kzalloc(4 * PRINT_LINE_LEN_MAX, GFP_KERNEL);
if (!data)
return NULL;
blob->data = data;
data += sprintf(data, "csr length: %d\n", debug->csr.word_count);
data += sprintf(data, "eeprom length: %d\n", debug->eeprom.word_count);
data += sprintf(data, "bbp length: %d\n", debug->bbp.word_count);
data += sprintf(data, "rf length: %d\n", debug->rf.word_count);
blob->size = strlen(blob->data);
return debugfs_create_blob(name, S_IRUGO, intf->driver_folder, blob);
}
/*
* ext4_snapshot_create_debugfs_entry - register ext4 debug hooks
* Void function doesn't return error if debug hooks are not registered.
*/
void ext4_snapshot_create_debugfs_entry(void)
{
int i;
ext4_debugfs_dir = debugfs_create_dir("ext4", NULL);
if (!ext4_debugfs_dir)
return;
snapshot_debug = debugfs_create_u8("snapshot-debug", S_IRUGO|S_IWUSR,
ext4_debugfs_dir,
&snapshot_enable_debug);
snapshot_version = debugfs_create_blob("snapshot-version", S_IRUGO,
ext4_debugfs_dir,
&snapshot_version_blob);
for (i = 0; i < SNAPSHOT_TESTS_NUM && i < SNAPSHOT_TEST_NAMES; i++)
snapshot_test[i] = debugfs_create_u16(snapshot_test_names[i],
S_IRUGO|S_IWUSR,
ext4_debugfs_dir,
&snapshot_enable_test[i]);
#ifdef CONFIG_EXT4_FS_SNAPSHOT_JOURNAL_CACHE
cow_cache = debugfs_create_u8("cow-cache", S_IRUGO,
ext4_debugfs_dir,
&cow_cache_offset);
#endif
}
struct link_device *lli_create_link_device(struct platform_device *pdev)
{
struct modem_data *modem;
struct mem_link_device *mld;
struct link_device *ld;
int err;
unsigned long start;
unsigned long size;
#ifdef DEBUG_MODEM_IF
struct dentry *debug_dir = debugfs_create_dir("svnet", NULL);
#endif
mif_err("+++\n");
/**
* Get the modem (platform) data
*/
modem = (struct modem_data *)pdev->dev.platform_data;
if (!modem) {
mif_err("ERR! modem == NULL\n");
return NULL;
}
if (!modem->gpio_ap_wakeup) {
mif_err("ERR! no gpio_ap_wakeup\n");
return NULL;
}
if (!modem->gpio_cp_status) {
mif_err("ERR! no gpio_cp_status\n");
return NULL;
}
mif_err("MODEM:%s LINK:%s\n", modem->name, modem->link_name);
/**
* Create a MEMORY link device instance
*/
mld = mem_create_link_device(MEM_LLI_SHMEM, modem);
if (!mld) {
mif_err("%s: ERR! create_link_device fail\n", modem->link_name);
return NULL;
}
g_mld = mld;
ld = &mld->link_dev;
ld->ready = lli_link_ready;
ld->reset = lli_link_reset;
ld->reload = lli_link_reload;
ld->off = lli_link_off;
ld->unmounted = lli_link_unmounted;
ld->suspended = lli_link_suspended;
ld->enable_irq = lli_enable_irq;
ld->disable_irq = lli_disable_irq;
/**
* Link local functions to the corresponding function pointers that are
* mandatory for all memory-type link devices
*/
mld->send_ap2cp_irq = send_ap2cp_irq;
/*
** Link local functions to the corresponding function pointers
*/
#ifndef CONFIG_LINK_POWER_MANAGEMENT_WITH_FSM
mld->finalize_cp_start = finalize_cp_start;
#endif
#ifdef CONFIG_LINK_POWER_MANAGEMENT
mld->start_pm = start_pm;
mld->stop_pm = stop_pm;
mld->forbid_cp_sleep = forbid_cp_sleep;
mld->permit_cp_sleep = permit_cp_sleep;
mld->link_active = check_link_status;
#endif
#ifdef DEBUG_MODEM_IF
mld->debug_info = mipi_lli_debug_info;
#endif
/**
* Initialize SHMEM maps for IPC (physical map -> logical map)
*/
start = mipi_lli_get_phys_base();
size = mipi_lli_get_phys_size();
err = mem_register_ipc_rgn(mld, start, size);
if (err < 0) {
mif_err("%s: ERR! register_ipc_rgn fail (%d)\n", ld->name, err);
goto error;
}
err = mem_setup_ipc_map(mld);
if (err < 0) {
mif_err("%s: ERR! setup_ipc_map fail (%d)\n", ld->name, err);
mem_unregister_ipc_rgn(mld);
goto error;
}
#ifdef CONFIG_LINK_DEVICE_WITH_SBD_ARCH
if (ld->sbd_ipc) {
struct sbd_link_device *sld = &mld->sbd_link_dev;
err = create_sbd_link_device(ld, sld, mld->base, mld->size);
if (err < 0)
goto error;
}
#endif
/**
* Register interrupt handlers
*/
err = mipi_lli_register_handler(lli_irq_handler, mld);
if (err) {
mif_err("%s: ERR! register_handler fail (%d)\n", ld->name, err);
goto error;
}
/*
** Retrieve GPIO#, IRQ#, and IRQ flags for PM
*/
mld->gpio_ap_wakeup = modem->gpio_ap_wakeup;
mld->gpio_cp_wakeup = modem->gpio_cp_wakeup;
mld->gpio_cp_status = modem->gpio_cp_status;
mld->gpio_ap_status = modem->gpio_ap_status;
mld->gpio_ipc_int2cp = modem->gpio_ipc_int2cp;
#ifdef CONFIG_LINK_POWER_MANAGEMENT
err = init_pm(mld);
if (err)
goto error;
#endif
#ifdef DEBUG_MODEM_IF
mld->mem_dump_blob.data = mld->base;
mld->mem_dump_blob.size = mld->size;
debugfs_create_blob("mem_dump", S_IRUGO, debug_dir,
&mld->mem_dump_blob);
#endif
mif_err("---\n");
return ld;
error:
kfree(mld);
mif_err("xxx\n");
return NULL;
}
void b2r2_debug_buffers_unresolve(struct b2r2_control *cont,
struct b2r2_blt_request *request)
{
enum b2r2_blt_fmt src_filter;
enum b2r2_blt_fmt dst_filter;
if (!cont->dump.capture || cont->dump.buffers_valid)
return;
mutex_lock(&cont->dump.lock);
/* Check input */
if (cont->dump.buffers_valid)
goto exit;
if (NULL != cont->dump.src_buffer) {
b2r2_log_err(cont->dev,
"%s: src_buffer already allocated\n",
__func__);
goto error;
}
if (NULL != cont->dump.dst_buffer) {
b2r2_log_err(cont->dev,
"%s: dst_buffer already allocated\n",
__func__);
goto error;
}
/* Check filters */
src_filter = cont->dump.src_filter;
if ((src_filter != 0) && (src_filter !=
request->user_req.src_img.fmt))
goto exit;
dst_filter = cont->dump.dst_filter;
if ((dst_filter != 0) && (dst_filter !=
request->user_req.dst_img.fmt))
goto exit;
cont->dump.src_size = request->src_resolved.file_len;
if (cont->dump.src_size > 0) {
/* Allocate source buffer */
b2r2_log_info(cont->dev,
"%s: Allocating %d bytes for src_buffer\n",
__func__, cont->dump.src_size);
cont->dump.src_buffer = vmalloc(cont->dump.src_size);
if (NULL == cont->dump.src_buffer) {
b2r2_log_err(cont->dev,
"%s: Failed to vmalloc src_buffer (%d bytes)\n",
__func__, cont->dump.src_size);
goto error;
}
/* Copy source buffer from request */
b2r2_log_info(cont->dev,
"%s: Copy from 0x%08X to 0x%08X, %d bytes\n",
__func__,
(u32)request->src_resolved.virtual_address,
(u32)cont->dump.src_buffer,
cont->dump.src_size);
memcpy(cont->dump.src_buffer,
request->src_resolved.virtual_address,
cont->dump.src_size);
/* Allocate debugfs apis for the source buffer */
cont->dump.debugfs_src_file = debugfs_create_file("src", 0444,
cont->dump.debugfs_root_dir, cont,
&dump_src_buffer_fops);
if (IS_ERR_OR_NULL(cont->dump.debugfs_src_file)) {
b2r2_log_err(cont->dev,
"%s: Failed to allocate debugfs src_buffer file\n",
__func__);
goto error;
}
/* Expose source info */
cont->dump.src_info.data = kmalloc(DUMP_INFO_MAX_SIZE,
GFP_KERNEL);
cont->dump.src_info.size = 0;
if (cont->dump.src_info.data == NULL) {
b2r2_log_err(cont->dev,
"%s: Failed to allocate src_info data\n",
__func__);
goto error;
}
cont->dump.src_info.size = snprintf(cont->dump.src_info.data,
DUMP_INFO_MAX_SIZE,
"format: %s (0x%08X)\n"
"width: %d\n"
"height: %d\n"
"pitch: %d\n",
b2r2_fmt_to_string(request->user_req.src_img.fmt),
request->user_req.src_img.fmt,
request->user_req.src_img.width,
request->user_req.src_img.height,
request->user_req.src_img.pitch);
cont->dump.debugfs_src_info = debugfs_create_blob("src_info",
0444, cont->dump.debugfs_root_dir,
&cont->dump.src_info);
if (IS_ERR_OR_NULL(cont->dump.debugfs_src_info)) {
b2r2_log_err(cont->dev,
"%s: Failed to allocate debugfs src_info file\n",
__func__);
goto error;
}
}
cont->dump.dst_size = request->dst_resolved.file_len;
if (cont->dump.dst_size > 0) {
/* Allocate destination buffer */
b2r2_log_info(cont->dev,
"%s: Allocating %d bytes for dst_buffer\n",
__func__, cont->dump.dst_size);
cont->dump.dst_buffer = vmalloc(cont->dump.dst_size);
if (NULL == cont->dump.dst_buffer) {
b2r2_log_err(cont->dev,
"%s: Failed to vmalloc dst_buffer "
"(%d bytes)\n", __func__,
cont->dump.dst_size);
goto error;
}
/* Copy buffers from request */
b2r2_log_info(cont->dev,
"%s: Copy from 0x%08X to 0x%08X, %d bytes\n",
__func__,
(u32)request->dst_resolved.virtual_address,
(u32)cont->dump.dst_buffer,
cont->dump.dst_size);
memcpy(cont->dump.dst_buffer,
request->dst_resolved.virtual_address,
cont->dump.dst_size);
/* Allocate debugfs apis for the destination buffer */
cont->dump.debugfs_dst_file = debugfs_create_file("dst", 0444,
cont->dump.debugfs_root_dir, cont,
&dump_dst_buffer_fops);
if (IS_ERR_OR_NULL(cont->dump.debugfs_dst_file)) {
b2r2_log_err(cont->dev,
"%s: Failed to allocate debugfs"
" dst_buffer file\n",
__func__);
goto error;
}
/* Expose destination info */
cont->dump.dst_info.data = kmalloc(DUMP_INFO_MAX_SIZE,
GFP_KERNEL);
cont->dump.dst_info.size = 0;
if (cont->dump.dst_info.data == NULL) {
b2r2_log_err(cont->dev,
"%s: Failed to allocate dst_info data\n",
__func__);
goto error;
}
cont->dump.dst_info.size = snprintf(cont->dump.dst_info.data,
DUMP_INFO_MAX_SIZE,
"format: %s (0x%08X)\n"
"width: %d\n"
"height: %d\n"
"pitch: %d\n",
b2r2_fmt_to_string(request->user_req.dst_img.fmt),
request->user_req.dst_img.fmt,
request->user_req.dst_img.width,
request->user_req.dst_img.height,
request->user_req.dst_img.pitch);
cont->dump.debugfs_dst_info = debugfs_create_blob("dst_info",
0444, cont->dump.debugfs_root_dir,
&cont->dump.dst_info);
if (IS_ERR_OR_NULL(cont->dump.debugfs_dst_info)) {
b2r2_log_err(cont->dev,
"%s: Failed to allocate debugfs"
" dst_info file\n",
__func__);
goto error;
}
}
/* Set buffers_valid */
cont->dump.buffers_valid = true;
exit:
mutex_unlock(&cont->dump.lock);
return;
error:
/* Free allocated resources */
dump_release_locked(cont);
mutex_unlock(&cont->dump.lock);
return;
}
