int main(int argc, char *argv[]) { int i; // Zero out the register for (i = 0; i < SKIROC2_SC_NWORDS; i++) { control_register->data[i] = 0; } //printf("'lookup_table' has %d entries.\n", LOOKUP_TABLE_SIZE); //dump_table(); // Before config printf("'control_register' has %d bits encoded in %d words.\n", SKIROC2_SC_NBITS, SKIROC2_SC_NWORDS); dump_register(); // After config printf("'control_register' after initialization with default values.\n"); skiroc2_slow_control_set_default(); dump_register(); // Write to file dump_register_to_file(); printf("Created file '%s'.\n", control_register_file); return 0; }
static void register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int properties) { char *dot_name, *flag_name, *glob_name; const char *prefix; char num[10]; int flags; /* See below in next_pass_1. */ num[0] = '\0'; if (pass->static_pass_number != -1) sprintf (num, "%d", ((int) pass->static_pass_number < 0 ? 1 : pass->static_pass_number)); dot_name = concat (".", pass->name, num, NULL); if (ipa) prefix = "ipa-", flags = TDF_IPA; else if (properties & PROP_trees) prefix = "tree-", flags = TDF_TREE; else prefix = "rtl-", flags = TDF_RTL; flag_name = concat (prefix, pass->name, num, NULL); glob_name = concat (prefix, pass->name, NULL); pass->static_pass_number = dump_register (dot_name, flag_name, glob_name, flags, pass->letter); }
void panic(char *str, unsigned long sp) { kernel_fatal("PANIC: caused by %s loop forever\n", str); dump_register(sp); while(1); }
int dump_registers(hackrf_device* device) { uint16_t register_number; int result = HACKRF_SUCCESS; for(register_number=0; register_number<256; register_number++) { result = dump_register(device, register_number); if( result != HACKRF_SUCCESS ) { break; } } return result; }
static void register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int n) { char *dot_name, *flag_name, *glob_name; char num[10]; /* See below in next_pass_1. */ num[0] = '\0'; if (pass->static_pass_number != -1) sprintf (num, "%d", ((int) pass->static_pass_number < 0 ? 1 : pass->static_pass_number)); dot_name = concat (".", pass->name, num, NULL); if (ipa) { flag_name = concat ("ipa-", pass->name, num, NULL); glob_name = concat ("ipa-", pass->name, NULL); /* First IPA dump is cgraph that is dumped via separate channels. */ pass->static_pass_number = dump_register (dot_name, flag_name, glob_name, TDF_IPA, n + 1, 0); } else if (pass->properties_provided & PROP_trees) { flag_name = concat ("tree-", pass->name, num, NULL); glob_name = concat ("tree-", pass->name, NULL); pass->static_pass_number = dump_register (dot_name, flag_name, glob_name, TDF_TREE, n + TDI_tree_all, 0); } else { flag_name = concat ("rtl-", pass->name, num, NULL); glob_name = concat ("rtl-", pass->name, NULL); pass->static_pass_number = dump_register (dot_name, flag_name, glob_name, TDF_RTL, n, pass->letter); } }
/** @brief Dump register value * * @param vfile virtual file which provide information to the user or system administrator * @param v * */ int dump_laura_register_read(struct seq_file *vfile, void *v){ int rc = 0; struct msm_laser_focus_ctrl_t *dev_t = get_laura_ctrl(); LOG_Handler(LOG_FUN, "%s: Enter\n", __func__); mutex_ctrl(dev_t, MUTEX_LOCK); /* Dump register value */ rc = dump_register(vfile, dev_t, DUMP_REGISTER_RANGE_MIN, DUMP_REGISTER_RANGE_MAX); mutex_ctrl(dev_t, MUTEX_UNLOCK); LOG_Handler(LOG_FUN, "%s: Exit\n", __func__); return rc; }
static void dump_registers(uint32_t regbase, uint32_t *dwords, uint32_t sizedwords, int level) { while (sizedwords--) { int last_summary = summary; /* access to non-banked registers needs a WFI: * TODO banked register range for a2xx?? */ if (needs_wfi && !is_banked_reg(regbase)) printf("NEEDS WFI: %s (%x)\n", regname(regbase, 1), regbase); type0_reg_vals[regbase] = *dwords; type0_reg_written[regbase/8] |= (1 << (regbase % 8)); dump_register(regbase, *dwords, level); regbase++; dwords++; summary = last_summary; } }
static int dbug_thread(void *unused) { while(g_start_debug_thread) { ACCFIX_DEBUG("dbug_thread INREG32(ACCDET_BASE + 0x0008)=%x\n",INREG32(ACCDET_BASE + 0x0008)); ACCFIX_DEBUG("[accfix]dbug_thread:sample_in:%x!\n", INREG32(ACCDET_SAMPLE_IN)); ACCFIX_DEBUG("[accfix]dbug_thread:curr_in:%x!\n", INREG32(ACCDET_CURR_IN)); ACCFIX_DEBUG("[accfix]dbug_thread:mem_in:%x!\n", INREG32(ACCDET_MEMORIZED_IN)); ACCFIX_DEBUG("[accfix]dbug_thread:FSM:%x!\n", INREG32(ACCDET_BASE + 0x0050)); ACCFIX_DEBUG("[accfix]dbug_thread:IRQ:%x!\n", INREG32(ACCDET_IRQ_STS)); if(g_dump_register) { dump_register(); dump_pmic_register(); } msleep(500); } return 0; }
#include <linux/usb/ch9.h> #include "core.h" #include "gadget.h" #include "io.h" #include "debug.h" #define dump_register(nm) \ { \ .name = __stringify(nm), \ .offset = DWC3_ ##nm - DWC3_GLOBALS_REGS_START, \ } static const struct debugfs_reg32 dwc3_regs[] = { dump_register(GSBUSCFG0), dump_register(GSBUSCFG1), dump_register(GTXTHRCFG), dump_register(GRXTHRCFG), dump_register(GCTL), dump_register(GEVTEN), dump_register(GSTS), dump_register(GSNPSID), dump_register(GGPIO), dump_register(GUID), dump_register(GUCTL), dump_register(GBUSERRADDR0), dump_register(GBUSERRADDR1), dump_register(GPRTBIMAP0), dump_register(GPRTBIMAP1), dump_register(GHWPARAMS0),
/* * xhci-debugfs.c - xHCI debugfs interface * * Copyright (C) 2017 Intel Corporation * * Author: Lu Baolu <*****@*****.**> */ #include <linux/slab.h> #include <linux/uaccess.h> #include "xhci.h" #include "xhci-debugfs.h" static const struct debugfs_reg32 xhci_cap_regs[] = { dump_register(CAPLENGTH), dump_register(HCSPARAMS1), dump_register(HCSPARAMS2), dump_register(HCSPARAMS3), dump_register(HCCPARAMS1), dump_register(DOORBELLOFF), dump_register(RUNTIMEOFF), dump_register(HCCPARAMS2), }; static const struct debugfs_reg32 xhci_op_regs[] = { dump_register(USBCMD), dump_register(USBSTS), dump_register(PAGESIZE), dump_register(DNCTRL), dump_register(CRCR),
#include <linux/io.h> #include <linux/kernel.h> #include <linux/seq_file.h> #include <linux/slab.h> #include <linux/types.h> #include "c8sectpfe-debugfs.h" #define dump_register(nm ...) \ { \ .name = #nm, \ .offset = nm, \ } static const struct debugfs_reg32 fei_sys_regs[] = { dump_register(SYS_INPUT_ERR_STATUS), dump_register(SYS_OTHER_ERR_STATUS), dump_register(SYS_INPUT_ERR_MASK), dump_register(SYS_DMA_ROUTE), dump_register(SYS_INPUT_CLKEN), dump_register(IBENABLE_MASK), dump_register(SYS_OTHER_CLKEN), dump_register(SYS_CFG_NUM_IB), dump_register(SYS_CFG_NUM_MIB), dump_register(SYS_CFG_NUM_SWTS), dump_register(SYS_CFG_NUM_TSOUT), dump_register(SYS_CFG_NUM_CCSC), dump_register(SYS_CFG_NUM_RAM), dump_register(SYS_CFG_NUM_TP), dump_register(C8SECTPFE_IB_IP_FMT_CFG(0)),
int main(int argc, char** argv) { int opt; uint16_t register_number = REGISTER_INVALID; uint16_t register_value; int result = hackrf_init(); if( result ) { printf("hackrf_init() failed: %s (%d)\n", hackrf_error_name(result), result); return -1; } hackrf_device* device = NULL; result = hackrf_open(&device); if( result ) { printf("hackrf_open() failed: %s (%d)\n", hackrf_error_name(result), result); return -1; } int option_index = 0; while( (opt = getopt_long(argc, argv, "cn:rw:", long_options, &option_index)) != EOF ) { switch( opt ) { case 'n': result = parse_int(optarg, ®ister_number); break; case 'w': result = parse_int(optarg, ®ister_value); if( result == HACKRF_SUCCESS ) { result = write_register(device, register_number, register_value); } break; case 'r': if( register_number == REGISTER_INVALID ) { result = dump_registers(device); } else { result = dump_register(device, register_number); } break; case 'c': dump_configuration(device); break; default: usage(); } if( result != HACKRF_SUCCESS ) { printf("argument error: %s (%d)\n", hackrf_error_name(result), result); break; } } result = hackrf_close(device); if( result ) { printf("hackrf_close() failed: %s (%d)\n", hackrf_error_name(result), result); return -1; } hackrf_exit(); return 0; }