/* * msm_rpm_log_copy() - Copies messages from a volatile circular buffer in * the RPM's shared memory into a private local buffer * msg_buffer: pointer to local buffer (string) * buf_len: length of local buffer in bytes * read_start_idx: index into shared memory buffer * * Return value: number of bytes written to the local buffer * * Copies messages stored in a circular buffer in the RPM Message Memory into * a specified local buffer. The RPM processor is unaware of these reading * efforts, so care is taken to make sure that messages are valid both before * and after reading. The RPM processor utilizes a ULog driver to write the * log. The RPM processor maintains tail and head indices. These correspond * to the next byte to write into, and the first valid byte, respectively. * Both indices increase monotonically (except for rollover). * * Messages take the form of [(u32)length] [(char)data0,1,...] in which the * length specifies the number of payload bytes. Messages must be 4 byte * aligned, so padding is added at the end of a message as needed. * * Print format: * - 0xXX, 0xXX, 0xXX * - 0xXX * etc... */ static u32 msm_rpm_log_copy(const struct msm_rpm_log_platform_data *pdata, char *msg_buffer, u32 buf_len, u32 *read_idx) { u32 head_idx, tail_idx; u32 pos = 0; u32 i = 0; u32 msg_len; u32 pos_start; char temp[4]; tail_idx = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_INDICES, MSM_RPM_LOG_TAIL); head_idx = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_INDICES, MSM_RPM_LOG_HEAD); while (tail_idx - head_idx > 0 && tail_idx - *read_idx > 0) { head_idx = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_INDICES, MSM_RPM_LOG_HEAD); if (tail_idx - *read_idx > tail_idx - head_idx) { *read_idx = head_idx; continue; } if (tail_idx - head_idx > pdata->log_len || !IS_ALIGNED((tail_idx | head_idx | *read_idx), 4)) break; msg_len = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_BUFFER, (*read_idx >> 2) & pdata->log_len_mask); if (PADDED_LENGTH(msg_len) > tail_idx - *read_idx - 4) msg_len = tail_idx - *read_idx - 4; if (pos + PRINTED_LENGTH(msg_len) > buf_len) break; pos_start = pos; pos += scnprintf(msg_buffer + pos, buf_len - pos, "- "); for (i = 0; i < msg_len; i++) { if (IS_ALIGNED(i, 4)) *((u32 *)temp) = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_BUFFER, ((*read_idx + 4 + i) >> 2) & pdata->log_len_mask); pos += scnprintf(msg_buffer + pos, buf_len - pos, "0x%02X, ", temp[i & 0x03]); } pos += scnprintf(msg_buffer + pos, buf_len - pos, "\n"); head_idx = msm_rpm_log_read(pdata, MSM_RPM_LOG_PAGE_INDICES, MSM_RPM_LOG_HEAD); if (tail_idx - *read_idx > tail_idx - head_idx) pos = pos_start; *read_idx += PADDED_LENGTH(msg_len) + 4; } return pos; }
/* * There's very little reason to use this, you should really * have a struct block_device just about everywhere and use * bdevname() instead. */ const char *__bdevname(dev_t dev, char *buffer) { scnprintf(buffer, BDEVNAME_SIZE, "unknown-block(%u,%u)", MAJOR(dev), MINOR(dev)); return buffer; }
static ssize_t qos_if_dls_mac(const struct ieee80211_sub_if_data *sdata, char *buf, int buflen) { return scnprintf(buf, buflen, MAC_FMT "\n", MAC_ARG(sdata->u.sta.dls_mac)); }
static int ins__raw_scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops) { return scnprintf(bf, size, "%-6.6s %s", ins->name, ops->raw); }
static ssize_t acpi_pad_idlepct_show(struct device *dev, struct device_attribute *attr, char *buf) { return scnprintf(buf, PAGE_SIZE, "%d\n", idle_pct); }
static ssize_t il_dbgfs_interrupt_read(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct il_priv *il = file->private_data; int pos = 0; int cnt = 0; char *buf; int bufsz = 24 * 64; /* 24 items * 64 char per item */ ssize_t ret; buf = kzalloc(bufsz, GFP_KERNEL); if (!buf) { IL_ERR("Can not allocate Buffer\n"); return -ENOMEM; } pos += scnprintf(buf + pos, bufsz - pos, "Interrupt Statistics Report:\n"); pos += scnprintf(buf + pos, bufsz - pos, "HW Error:\t\t\t %u\n", il->isr_stats.hw); pos += scnprintf(buf + pos, bufsz - pos, "SW Error:\t\t\t %u\n", il->isr_stats.sw); if (il->isr_stats.sw || il->isr_stats.hw) { pos += scnprintf(buf + pos, bufsz - pos, "\tLast Restarting Code: 0x%X\n", il->isr_stats.err_code); } #ifdef CONFIG_IWLEGACY_DEBUG pos += scnprintf(buf + pos, bufsz - pos, "Frame transmitted:\t\t %u\n", il->isr_stats.sch); pos += scnprintf(buf + pos, bufsz - pos, "Alive interrupt:\t\t %u\n", il->isr_stats.alive); #endif pos += scnprintf(buf + pos, bufsz - pos, "HW RF KILL switch toggled:\t %u\n", il->isr_stats.rfkill); pos += scnprintf(buf + pos, bufsz - pos, "CT KILL:\t\t\t %u\n", il->isr_stats.ctkill); pos += scnprintf(buf + pos, bufsz - pos, "Wakeup Interrupt:\t\t %u\n", il->isr_stats.wakeup); pos += scnprintf(buf + pos, bufsz - pos, "Rx command responses:\t\t %u\n", il->isr_stats.rx); for (cnt = 0; cnt < IL_CN_MAX; cnt++) { if (il->isr_stats.handlers[cnt] > 0) pos += scnprintf(buf + pos, bufsz - pos, "\tRx handler[%36s]:\t\t %u\n", il_get_cmd_string(cnt), il->isr_stats.handlers[cnt]); } pos += scnprintf(buf + pos, bufsz - pos, "Tx/FH interrupt:\t\t %u\n", il->isr_stats.tx); pos += scnprintf(buf + pos, bufsz - pos, "Unexpected INTA:\t\t %u\n", il->isr_stats.unhandled); ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); kfree(buf); return ret; }
int p9_printfcall(char *buf, int buflen, struct p9_fcall *fc, int extended) { int i, ret, type, tag; if (!fc) return scnprintf(buf, buflen, "<NULL>"); type = fc->id; tag = fc->tag; ret = 0; switch (type) { case P9_TVERSION: ret += scnprintf(buf+ret, buflen-ret, "Tversion tag %u msize %u version '%.*s'", tag, fc->params.tversion.msize, fc->params.tversion.version.len, fc->params.tversion.version.str); break; case P9_RVERSION: ret += scnprintf(buf+ret, buflen-ret, "Rversion tag %u msize %u version '%.*s'", tag, fc->params.rversion.msize, fc->params.rversion.version.len, fc->params.rversion.version.str); break; case P9_TAUTH: ret += scnprintf(buf+ret, buflen-ret, "Tauth tag %u afid %d uname '%.*s' aname '%.*s'", tag, fc->params.tauth.afid, fc->params.tauth.uname.len, fc->params.tauth.uname.str, fc->params.tauth.aname.len, fc->params.tauth.aname.str); break; case P9_RAUTH: ret += scnprintf(buf+ret, buflen-ret, "Rauth tag %u qid ", tag); p9_printqid(buf+ret, buflen-ret, &fc->params.rauth.qid); break; case P9_TATTACH: ret += scnprintf(buf+ret, buflen-ret, "Tattach tag %u fid %d afid %d uname '%.*s' aname '%.*s'", tag, fc->params.tattach.fid, fc->params.tattach.afid, fc->params.tattach.uname.len, fc->params.tattach.uname.str, fc->params.tattach.aname.len, fc->params.tattach.aname.str); break; case P9_RATTACH: ret += scnprintf(buf+ret, buflen-ret, "Rattach tag %u qid ", tag); p9_printqid(buf+ret, buflen-ret, &fc->params.rattach.qid); break; case P9_RERROR: ret += scnprintf(buf+ret, buflen-ret, "Rerror tag %u ename '%.*s'", tag, fc->params.rerror.error.len, fc->params.rerror.error.str); if (extended) ret += scnprintf(buf+ret, buflen-ret, " ecode %d\n", fc->params.rerror.errno); break; case P9_TFLUSH: ret += scnprintf(buf+ret, buflen-ret, "Tflush tag %u oldtag %u", tag, fc->params.tflush.oldtag); break; case P9_RFLUSH: ret += scnprintf(buf+ret, buflen-ret, "Rflush tag %u", tag); break; case P9_TWALK: ret += scnprintf(buf+ret, buflen-ret, "Twalk tag %u fid %d newfid %d nwname %d", tag, fc->params.twalk.fid, fc->params.twalk.newfid, fc->params.twalk.nwname); for (i = 0; i < fc->params.twalk.nwname; i++) ret += scnprintf(buf+ret, buflen-ret, " '%.*s'", fc->params.twalk.wnames[i].len, fc->params.twalk.wnames[i].str); break; case P9_RWALK: ret += scnprintf(buf+ret, buflen-ret, "Rwalk tag %u nwqid %d", tag, fc->params.rwalk.nwqid); for (i = 0; i < fc->params.rwalk.nwqid; i++) ret += p9_printqid(buf+ret, buflen-ret, &fc->params.rwalk.wqids[i]); break; case P9_TOPEN: ret += scnprintf(buf+ret, buflen-ret, "Topen tag %u fid %d mode %d", tag, fc->params.topen.fid, fc->params.topen.mode); break; case P9_ROPEN: ret += scnprintf(buf+ret, buflen-ret, "Ropen tag %u", tag); ret += p9_printqid(buf+ret, buflen-ret, &fc->params.ropen.qid); ret += scnprintf(buf+ret, buflen-ret, " iounit %d", fc->params.ropen.iounit); break; case P9_TCREATE: ret += scnprintf(buf+ret, buflen-ret, "Tcreate tag %u fid %d name '%.*s' perm ", tag, fc->params.tcreate.fid, fc->params.tcreate.name.len, fc->params.tcreate.name.str); ret += p9_printperm(buf+ret, buflen-ret, fc->params.tcreate.perm); ret += scnprintf(buf+ret, buflen-ret, " mode %d", fc->params.tcreate.mode); break; case P9_RCREATE: ret += scnprintf(buf+ret, buflen-ret, "Rcreate tag %u", tag); ret += p9_printqid(buf+ret, buflen-ret, &fc->params.rcreate.qid); ret += scnprintf(buf+ret, buflen-ret, " iounit %d", fc->params.rcreate.iounit); break; case P9_TREAD: ret += scnprintf(buf+ret, buflen-ret, "Tread tag %u fid %d offset %lld count %u", tag, fc->params.tread.fid, (long long int) fc->params.tread.offset, fc->params.tread.count); break; case P9_RREAD: ret += scnprintf(buf+ret, buflen-ret, "Rread tag %u count %u data ", tag, fc->params.rread.count); ret += p9_printdata(buf+ret, buflen-ret, fc->params.rread.data, fc->params.rread.count); break; case P9_TWRITE: ret += scnprintf(buf+ret, buflen-ret, "Twrite tag %u fid %d offset %lld count %u data ", tag, fc->params.twrite.fid, (long long int) fc->params.twrite.offset, fc->params.twrite.count); ret += p9_printdata(buf+ret, buflen-ret, fc->params.twrite.data, fc->params.twrite.count); break; case P9_RWRITE: ret += scnprintf(buf+ret, buflen-ret, "Rwrite tag %u count %u", tag, fc->params.rwrite.count); break; case P9_TCLUNK: ret += scnprintf(buf+ret, buflen-ret, "Tclunk tag %u fid %d", tag, fc->params.tclunk.fid); break; case P9_RCLUNK: ret += scnprintf(buf+ret, buflen-ret, "Rclunk tag %u", tag); break; case P9_TREMOVE: ret += scnprintf(buf+ret, buflen-ret, "Tremove tag %u fid %d", tag, fc->params.tremove.fid); break; case P9_RREMOVE: ret += scnprintf(buf+ret, buflen-ret, "Rremove tag %u", tag); break; case P9_TSTAT: ret += scnprintf(buf+ret, buflen-ret, "Tstat tag %u fid %d", tag, fc->params.tstat.fid); break; case P9_RSTAT: ret += scnprintf(buf+ret, buflen-ret, "Rstat tag %u ", tag); ret += p9_printstat(buf+ret, buflen-ret, &fc->params.rstat.stat, extended); break; case P9_TWSTAT: ret += scnprintf(buf+ret, buflen-ret, "Twstat tag %u fid %d ", tag, fc->params.twstat.fid); ret += p9_printstat(buf+ret, buflen-ret, &fc->params.twstat.stat, extended); break; case P9_RWSTAT: ret += scnprintf(buf+ret, buflen-ret, "Rwstat tag %u", tag); break; default: ret += scnprintf(buf+ret, buflen-ret, "unknown type %d", type); break; } return ret; }
static int debug_test_smsm(char *buf, int max) { int i = 0; int test_num = 0; int ret; /* Test case 1 - Register new callback for notification */ do { test_num++; SMSM_CB_TEST_INIT(); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 0); /* de-assert SMSM_SMD_INIT to trigger state update */ UT_EQ_INT(smsm_cb_data.cb_count, 0); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 1); UT_EQ_INT(smsm_cb_data.old_state & SMSM_SMDINIT, SMSM_SMDINIT); UT_EQ_INT(smsm_cb_data.new_state & SMSM_SMDINIT, 0x0); UT_EQ_INT((int)smsm_cb_data.data, 0x1234); /* re-assert SMSM_SMD_INIT to trigger state update */ INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); UT_EQ_INT(smsm_cb_data.old_state & SMSM_SMDINIT, 0x0); UT_EQ_INT(smsm_cb_data.new_state & SMSM_SMDINIT, SMSM_SMDINIT); /* deregister callback */ ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 2); /* make sure state change doesn't cause any more callbacks */ INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_EQ_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); i += scnprintf(buf + i, max - i, "Test %d - PASS\n", test_num); } while (0); /* Test case 2 - Update already registered callback */ do { test_num++; SMSM_CB_TEST_INIT(); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 0); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 1); /* verify both callback bits work */ INIT_COMPLETION(smsm_cb_completion); UT_EQ_INT(smsm_cb_data.cb_count, 0); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 1); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 3); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 4); /* deregister 1st callback */ ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 1); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_EQ_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 4); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 5); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 6); /* deregister 2nd callback */ ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 2); /* make sure state change doesn't cause any more callbacks */ INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); UT_EQ_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 6); i += scnprintf(buf + i, max - i, "Test %d - PASS\n", test_num); } while (0); /* Test case 3 - Two callback registrations with different data */ do { test_num++; SMSM_CB_TEST_INIT(); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 0); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x3456); UT_EQ_INT(ret, 0); /* verify both callbacks work */ INIT_COMPLETION(smsm_cb_completion); UT_EQ_INT(smsm_cb_data.cb_count, 0); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 1); UT_EQ_INT((int)smsm_cb_data.data, 0x1234); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); UT_EQ_INT((int)smsm_cb_data.data, 0x3456); /* cleanup and unregister * degregister in reverse to verify data field is * being used */ smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x3456); UT_EQ_INT(ret, 2); ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 2); i += scnprintf(buf + i, max - i, "Test %d - PASS\n", test_num); } while (0); return i; }
static char *arc_cpu_mumbojumbo(int cpu_id, char *buf, int len) { struct cpuinfo_arc *cpu = &cpuinfo_arc700[cpu_id]; struct bcr_identity *core = &cpu->core; const struct cpuinfo_data *tbl; char *isa_nm; int i, be, atomic; int n = 0; FIX_PTR(cpu); if (is_isa_arcompact()) { isa_nm = "ARCompact"; be = IS_ENABLED(CONFIG_CPU_BIG_ENDIAN); atomic = cpu->isa.atomic1; if (!cpu->isa.ver) /* ISA BCR absent, use Kconfig info */ atomic = IS_ENABLED(CONFIG_ARC_HAS_LLSC); } else { isa_nm = "ARCv2"; be = cpu->isa.be; atomic = cpu->isa.atomic; } n += scnprintf(buf + n, len - n, "\nIDENTITY\t: ARCVER [%#02x] ARCNUM [%#02x] CHIPID [%#4x]\n", core->family, core->cpu_id, core->chip_id); for (tbl = &arc_cpu_tbl[0]; tbl->info.id != 0; tbl++) { if ((core->family >= tbl->info.id) && (core->family <= tbl->up_range)) { n += scnprintf(buf + n, len - n, "processor [%d]\t: %s (%s ISA) %s\n", cpu_id, tbl->info.str, isa_nm, IS_AVAIL1(be, "[Big-Endian]")); break; } } if (tbl->info.id == 0) n += scnprintf(buf + n, len - n, "UNKNOWN ARC Processor\n"); n += scnprintf(buf + n, len - n, "CPU speed\t: %u.%02u Mhz\n", (unsigned int)(arc_get_core_freq() / 1000000), (unsigned int)(arc_get_core_freq() / 10000) % 100); n += scnprintf(buf + n, len - n, "Timers\t\t: %s%s%s%s\nISA Extn\t: ", IS_AVAIL1(cpu->timers.t0, "Timer0 "), IS_AVAIL1(cpu->timers.t1, "Timer1 "), IS_AVAIL2(cpu->timers.rtc, "64-bit RTC ", CONFIG_ARC_HAS_RTC)); n += i = scnprintf(buf + n, len - n, "%s%s%s%s%s", IS_AVAIL2(atomic, "atomic ", CONFIG_ARC_HAS_LLSC), IS_AVAIL2(cpu->isa.ldd, "ll64 ", CONFIG_ARC_HAS_LL64), IS_AVAIL1(cpu->isa.unalign, "unalign (not used)")); if (i) n += scnprintf(buf + n, len - n, "\n\t\t: "); if (cpu->extn_mpy.ver) { if (cpu->extn_mpy.ver <= 0x2) { /* ARCompact */ n += scnprintf(buf + n, len - n, "mpy "); } else { int opt = 2; /* stock MPY/MPYH */ if (cpu->extn_mpy.dsp) /* OPT 7-9 */ opt = cpu->extn_mpy.dsp + 6; n += scnprintf(buf + n, len - n, "mpy[opt %d] ", opt); } n += scnprintf(buf + n, len - n, "%s", IS_USED_CFG(CONFIG_ARC_HAS_HW_MPY)); } n += scnprintf(buf + n, len - n, "%s%s%s%s%s%s%s%s\n", IS_AVAIL1(cpu->isa.div_rem, "div_rem "), IS_AVAIL1(cpu->extn.norm, "norm "), IS_AVAIL1(cpu->extn.barrel, "barrel-shift "), IS_AVAIL1(cpu->extn.swap, "swap "), IS_AVAIL1(cpu->extn.minmax, "minmax "), IS_AVAIL1(cpu->extn.crc, "crc "), IS_AVAIL2(1, "swape", CONFIG_ARC_HAS_SWAPE)); if (cpu->bpu.ver) n += scnprintf(buf + n, len - n, "BPU\t\t: %s%s match, cache:%d, Predict Table:%d\n", IS_AVAIL1(cpu->bpu.full, "full"), IS_AVAIL1(!cpu->bpu.full, "partial"), cpu->bpu.num_cache, cpu->bpu.num_pred); return buf; }
static ssize_t ieee80211_if_fmt_num_buffered_multicast( const struct ieee80211_sub_if_data *sdata, char *buf, int buflen) { return scnprintf(buf, buflen, "%u\n", skb_queue_len(&sdata->u.ap.ps.bc_buf)); }
/** * Dump individual input/output item pair. * * @s: pointer to output file */ static void smp2p_item(struct seq_file *s, int remote_pid) { struct smp2p_smem *out_ptr; struct smp2p_smem *in_ptr; struct smp2p_interrupt_config *int_cfg; char tmp_buff[64]; int state; int entry; struct smp2p_entry_v1 *out_entries = NULL; struct smp2p_entry_v1 *in_entries = NULL; int out_valid = 0; int in_valid = 0; int_cfg = smp2p_get_interrupt_config(); if (!int_cfg) return; if (!int_cfg[remote_pid].is_configured && remote_pid != SMP2P_REMOTE_MOCK_PROC) return; out_ptr = smp2p_get_out_item(remote_pid, &state); in_ptr = smp2p_get_in_item(remote_pid); if (!out_ptr && !in_ptr) return; /* print item headers */ seq_printf(s, "%s%s\n", " ====================================== ", "======================================"); scnprintf(tmp_buff, sizeof(tmp_buff), "Apps(%d)->%s(%d)", SMP2P_APPS_PROC, int_cfg[remote_pid].name, remote_pid); seq_printf(s, "| %-37s", tmp_buff); scnprintf(tmp_buff, sizeof(tmp_buff), "%s(%d)->Apps(%d)", int_cfg[remote_pid].name, remote_pid, SMP2P_APPS_PROC); seq_printf(s, "| %-37s|\n", tmp_buff); seq_printf(s, "%s%s\n", " ====================================== ", "======================================"); smp2p_item_header1(tmp_buff, sizeof(tmp_buff), out_ptr, state); seq_printf(s, "| %-37s", tmp_buff); smp2p_item_header1(tmp_buff, sizeof(tmp_buff), in_ptr, -1); seq_printf(s, "| %-37s|\n", tmp_buff); smp2p_item_header2(tmp_buff, sizeof(tmp_buff), out_ptr); seq_printf(s, "| %-37s", tmp_buff); smp2p_item_header2(tmp_buff, sizeof(tmp_buff), in_ptr); seq_printf(s, "| %-37s|\n", tmp_buff); smp2p_item_header3(tmp_buff, sizeof(tmp_buff), out_ptr); seq_printf(s, "| %-37s", tmp_buff); smp2p_item_header3(tmp_buff, sizeof(tmp_buff), in_ptr); seq_printf(s, "| %-37s|\n", tmp_buff); seq_printf(s, " %s%s\n", "-------------------------------------- ", "--------------------------------------"); seq_printf(s, "| %-37s", "Entry Name Value"); seq_printf(s, "| %-37s|\n", "Entry Name Value"); seq_printf(s, " %s%s\n", "-------------------------------------- ", "--------------------------------------"); /* print entries */ if (out_ptr) { out_entries = (struct smp2p_entry_v1 *)((void *)out_ptr + sizeof(struct smp2p_smem)); out_valid = SMP2P_GET_ENT_VALID(out_ptr->valid_total_ent); } if (in_ptr) { in_entries = (struct smp2p_entry_v1 *)((void *)in_ptr + sizeof(struct smp2p_smem)); in_valid = SMP2P_GET_ENT_VALID(in_ptr->valid_total_ent); } for (entry = 0; out_entries || in_entries; ++entry) { if (out_entries && entry < out_valid) { scnprintf(tmp_buff, sizeof(tmp_buff), "%-16s 0x%08x", out_entries->name, out_entries->entry); ++out_entries; } else { out_entries = NULL; scnprintf(tmp_buff, sizeof(tmp_buff), "None"); } seq_printf(s, "| %-37s", tmp_buff); if (in_entries && entry < in_valid) { scnprintf(tmp_buff, sizeof(tmp_buff), "%-16s 0x%08x", in_entries->name, in_entries->entry); ++in_entries; } else { in_entries = NULL; scnprintf(tmp_buff, sizeof(tmp_buff), "None"); } seq_printf(s, "| %-37s|\n", tmp_buff); } seq_printf(s, " %s%s\n\n", "-------------------------------------- ", "--------------------------------------"); }
static ssize_t read_file_antenna_diversity(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct ath_softc *sc = file->private_data; struct ath_hw *ah = sc->sc_ah; struct ath9k_hw_capabilities *pCap = &ah->caps; struct ath_antenna_stats *as_main = &sc->debug.stats.ant_stats[ANT_MAIN]; struct ath_antenna_stats *as_alt = &sc->debug.stats.ant_stats[ANT_ALT]; struct ath_hw_antcomb_conf div_ant_conf; unsigned int len = 0; const unsigned int size = 1024; ssize_t retval = 0; char *buf; static const char *lna_conf_str[4] = { "LNA1_MINUS_LNA2", "LNA2", "LNA1", "LNA1_PLUS_LNA2" }; buf = kzalloc(size, GFP_KERNEL); if (buf == NULL) return -ENOMEM; if (!(pCap->hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)) { len += scnprintf(buf + len, size - len, "%s\n", "Antenna Diversity Combining is disabled"); goto exit; } ath9k_ps_wakeup(sc); ath9k_hw_antdiv_comb_conf_get(ah, &div_ant_conf); len += scnprintf(buf + len, size - len, "Current MAIN config : %s\n", lna_conf_str[div_ant_conf.main_lna_conf]); len += scnprintf(buf + len, size - len, "Current ALT config : %s\n", lna_conf_str[div_ant_conf.alt_lna_conf]); len += scnprintf(buf + len, size - len, "Average MAIN RSSI : %d\n", as_main->rssi_avg); len += scnprintf(buf + len, size - len, "Average ALT RSSI : %d\n\n", as_alt->rssi_avg); ath9k_ps_restore(sc); len += scnprintf(buf + len, size - len, "Packet Receive Cnt:\n"); len += scnprintf(buf + len, size - len, "-------------------\n"); len += scnprintf(buf + len, size - len, "%30s%15s\n", "MAIN", "ALT"); len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", "TOTAL COUNT", as_main->recv_cnt, as_alt->recv_cnt); len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", "LNA1", as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1], as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1]); len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", "LNA2", as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA2], as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA2]); len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", "LNA1 + LNA2", as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2], as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2]); len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", "LNA1 - LNA2", as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2], as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2]); len += scnprintf(buf + len, size - len, "\nLNA Config Attempts:\n"); len += scnprintf(buf + len, size - len, "--------------------\n"); len += scnprintf(buf + len, size - len, "%30s%15s\n", "MAIN", "ALT"); len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", "LNA1", as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1], as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1]); len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", "LNA2", as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA2], as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA2]); len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", "LNA1 + LNA2", as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2], as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2]); len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", "LNA1 - LNA2", as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2], as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2]); exit: if (len > size) len = size; retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); kfree(buf); return retval; }
/** * iwl_print_event_log - Dump error event log to syslog * */ static int iwl_print_event_log(struct iwl_trans *trans, u32 start_idx, u32 num_events, u32 mode, int pos, char **buf, size_t bufsz) { u32 i; u32 base; /* SRAM byte address of event log header */ u32 event_size; /* 2 u32s, or 3 u32s if timestamp recorded */ u32 ptr; /* SRAM byte address of log data */ u32 ev, time, data; /* event log data */ unsigned long reg_flags; if (num_events == 0) return pos; base = trans->shrd->device_pointers.log_event_table; if (trans->shrd->ucode_type == IWL_UCODE_INIT) { if (!base) base = trans->shrd->fw->init_evtlog_ptr; } else { if (!base) base = trans->shrd->fw->inst_evtlog_ptr; } if (mode == 0) event_size = 2 * sizeof(u32); else event_size = 3 * sizeof(u32); ptr = base + EVENT_START_OFFSET + (start_idx * event_size); /* Make sure device is powered up for SRAM reads */ spin_lock_irqsave(&trans->reg_lock, reg_flags); if (unlikely(!iwl_grab_nic_access(trans))) goto out_unlock; /* Set starting address; reads will auto-increment */ iwl_write32(trans, HBUS_TARG_MEM_RADDR, ptr); /* "time" is actually "data" for mode 0 (no timestamp). * place event id # at far right for easier visual parsing. */ for (i = 0; i < num_events; i++) { ev = iwl_read32(trans, HBUS_TARG_MEM_RDAT); time = iwl_read32(trans, HBUS_TARG_MEM_RDAT); if (mode == 0) { /* data, ev */ if (bufsz) { pos += scnprintf(*buf + pos, bufsz - pos, "EVT_LOG:0x%08x:%04u\n", time, ev); } else { trace_iwlwifi_dev_ucode_event(trans->dev, 0, time, ev); IWL_ERR(trans, "EVT_LOG:0x%08x:%04u\n", time, ev); } } else { data = iwl_read32(trans, HBUS_TARG_MEM_RDAT); if (bufsz) { pos += scnprintf(*buf + pos, bufsz - pos, "EVT_LOGT:%010u:0x%08x:%04u\n", time, data, ev); } else { IWL_ERR(trans, "EVT_LOGT:%010u:0x%08x:%04u\n", time, data, ev); trace_iwlwifi_dev_ucode_event(trans->dev, time, data, ev); } } } /* Allow device to power down */ iwl_release_nic_access(trans); out_unlock: spin_unlock_irqrestore(&trans->reg_lock, reg_flags); return pos; }
int dso__read_binary_type_filename(const struct dso *dso, enum dso_binary_type type, char *root_dir, char *filename, size_t size) { char build_id_hex[BUILD_ID_SIZE * 2 + 1]; int ret = 0; switch (type) { case DSO_BINARY_TYPE__DEBUGLINK: { char *debuglink; strncpy(filename, dso->long_name, size); debuglink = filename + dso->long_name_len; while (debuglink != filename && *debuglink != '/') debuglink--; if (*debuglink == '/') debuglink++; filename__read_debuglink(dso->long_name, debuglink, size - (debuglink - filename)); } break; case DSO_BINARY_TYPE__BUILD_ID_CACHE: /* skip the locally configured cache if a symfs is given */ if (symbol_conf.symfs[0] || (dso__build_id_filename(dso, filename, size) == NULL)) ret = -1; break; case DSO_BINARY_TYPE__FEDORA_DEBUGINFO: snprintf(filename, size, "%s/usr/lib/debug%s.debug", symbol_conf.symfs, dso->long_name); break; case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO: snprintf(filename, size, "%s/usr/lib/debug%s", symbol_conf.symfs, dso->long_name); break; case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO: { const char *last_slash; size_t len; size_t dir_size; last_slash = dso->long_name + dso->long_name_len; while (last_slash != dso->long_name && *last_slash != '/') last_slash--; len = scnprintf(filename, size, "%s", symbol_conf.symfs); dir_size = last_slash - dso->long_name + 2; if (dir_size > (size - len)) { ret = -1; break; } len += scnprintf(filename + len, dir_size, "%s", dso->long_name); len += scnprintf(filename + len , size - len, ".debug%s", last_slash); break; } case DSO_BINARY_TYPE__BUILDID_DEBUGINFO: if (!dso->has_build_id) { ret = -1; break; } build_id__sprintf(dso->build_id, sizeof(dso->build_id), build_id_hex); snprintf(filename, size, "%s/usr/lib/debug/.build-id/%.2s/%s.debug", symbol_conf.symfs, build_id_hex, build_id_hex + 2); break; case DSO_BINARY_TYPE__VMLINUX: case DSO_BINARY_TYPE__GUEST_VMLINUX: case DSO_BINARY_TYPE__SYSTEM_PATH_DSO: snprintf(filename, size, "%s%s", symbol_conf.symfs, dso->long_name); break; case DSO_BINARY_TYPE__GUEST_KMODULE: snprintf(filename, size, "%s%s%s", symbol_conf.symfs, root_dir, dso->long_name); break; case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE: snprintf(filename, size, "%s%s", symbol_conf.symfs, dso->long_name); break; case DSO_BINARY_TYPE__KCORE: case DSO_BINARY_TYPE__GUEST_KCORE: snprintf(filename, size, "%s", dso->long_name); break; default: case DSO_BINARY_TYPE__KALLSYMS: case DSO_BINARY_TYPE__GUEST_KALLSYMS: case DSO_BINARY_TYPE__JAVA_JIT: case DSO_BINARY_TYPE__NOT_FOUND: ret = -1; break; } return ret; }
static ssize_t il_dbgfs_channels_read(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct il_priv *il = file->private_data; struct ieee80211_channel *channels = NULL; const struct ieee80211_supported_band *supp_band = NULL; int pos = 0, i, bufsz = PAGE_SIZE; char *buf; ssize_t ret; if (!test_bit(S_GEO_CONFIGURED, &il->status)) return -EAGAIN; buf = kzalloc(bufsz, GFP_KERNEL); if (!buf) { IL_ERR("Can not allocate Buffer\n"); return -ENOMEM; } supp_band = il_get_hw_mode(il, IEEE80211_BAND_2GHZ); if (supp_band) { channels = supp_band->channels; pos += scnprintf(buf + pos, bufsz - pos, "Displaying %d channels in 2.4GHz band 802.11bg):\n", supp_band->n_channels); for (i = 0; i < supp_band->n_channels; i++) pos += scnprintf(buf + pos, bufsz - pos, "%d: %ddBm: BSS%s%s, %s.\n", channels[i].hw_value, channels[i].max_power, channels[i]. flags & IEEE80211_CHAN_RADAR ? " (IEEE 802.11h required)" : "", ((channels[i]. flags & IEEE80211_CHAN_NO_IR) || (channels[i]. flags & IEEE80211_CHAN_RADAR)) ? "" : ", IBSS", channels[i]. flags & IEEE80211_CHAN_NO_IR ? "passive only" : "active/passive"); } supp_band = il_get_hw_mode(il, IEEE80211_BAND_5GHZ); if (supp_band) { channels = supp_band->channels; pos += scnprintf(buf + pos, bufsz - pos, "Displaying %d channels in 5.2GHz band (802.11a)\n", supp_band->n_channels); for (i = 0; i < supp_band->n_channels; i++) pos += scnprintf(buf + pos, bufsz - pos, "%d: %ddBm: BSS%s%s, %s.\n", channels[i].hw_value, channels[i].max_power, channels[i]. flags & IEEE80211_CHAN_RADAR ? " (IEEE 802.11h required)" : "", ((channels[i]. flags & IEEE80211_CHAN_NO_IR) || (channels[i]. flags & IEEE80211_CHAN_RADAR)) ? "" : ", IBSS", channels[i]. flags & IEEE80211_CHAN_NO_IR ? "passive only" : "active/passive"); } ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); kfree(buf); return ret; }
static void dbg_log_event(struct urb *urb, char * event, unsigned extra) { unsigned long flags; int ep_addr; char tbuf[TIME_BUF_LEN]; if (!enable_dbg_log) return; if (!urb) { write_lock_irqsave(&dbg_hsic_ctrl.lck, flags); scnprintf(dbg_hsic_ctrl.buf[dbg_hsic_ctrl.idx], DBG_MSG_LEN, "%s: %s : %u\n", get_timestamp(tbuf), event, extra); dbg_inc(&dbg_hsic_ctrl.idx); write_unlock_irqrestore(&dbg_hsic_ctrl.lck, flags); return; } ep_addr = urb->ep->desc.bEndpointAddress; if (!allow_dbg_log(ep_addr)) return; if ((ep_addr & 0x0f) == 0x0) { /*submit event*/ if (!str_to_event(event)) { write_lock_irqsave(&dbg_hsic_ctrl.lck, flags); scnprintf(dbg_hsic_ctrl.buf[dbg_hsic_ctrl.idx], DBG_MSG_LEN, "%s: [%s : %p]:[%s] " "%02x %02x %04x %04x %04x %u %d\n", get_timestamp(tbuf), event, urb, (ep_addr & USB_DIR_IN) ? "in" : "out", urb->setup_packet[0], urb->setup_packet[1], (urb->setup_packet[3] << 8) | urb->setup_packet[2], (urb->setup_packet[5] << 8) | urb->setup_packet[4], (urb->setup_packet[7] << 8) | urb->setup_packet[6], urb->transfer_buffer_length, urb->status); dbg_inc(&dbg_hsic_ctrl.idx); write_unlock_irqrestore(&dbg_hsic_ctrl.lck, flags); } else { write_lock_irqsave(&dbg_hsic_ctrl.lck, flags); scnprintf(dbg_hsic_ctrl.buf[dbg_hsic_ctrl.idx], DBG_MSG_LEN, "%s: [%s : %p]:[%s] %u %d\n", get_timestamp(tbuf), event, urb, (ep_addr & USB_DIR_IN) ? "in" : "out", urb->actual_length, extra); dbg_inc(&dbg_hsic_ctrl.idx); write_unlock_irqrestore(&dbg_hsic_ctrl.lck, flags); } } else { write_lock_irqsave(&dbg_hsic_data.lck, flags); scnprintf(dbg_hsic_data.buf[dbg_hsic_data.idx], DBG_MSG_LEN, "%s: [%s : %p]:ep%d[%s] %u %d\n", get_timestamp(tbuf), event, urb, ep_addr & 0x0f, (ep_addr & USB_DIR_IN) ? "in" : "out", str_to_event(event) ? urb->actual_length : urb->transfer_buffer_length, str_to_event(event) ? extra : urb->status); dbg_inc(&dbg_hsic_data.idx); write_unlock_irqrestore(&dbg_hsic_data.lck, flags); } }
static ssize_t il_dbgfs_status_read(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct il_priv *il = file->private_data; char buf[512]; int pos = 0; const size_t bufsz = sizeof(buf); pos += scnprintf(buf + pos, bufsz - pos, "S_HCMD_ACTIVE:\t %d\n", test_bit(S_HCMD_ACTIVE, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_INT_ENABLED:\t %d\n", test_bit(S_INT_ENABLED, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_RFKILL:\t %d\n", test_bit(S_RFKILL, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_CT_KILL:\t\t %d\n", test_bit(S_CT_KILL, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_INIT:\t\t %d\n", test_bit(S_INIT, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_ALIVE:\t\t %d\n", test_bit(S_ALIVE, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_READY:\t\t %d\n", test_bit(S_READY, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_TEMPERATURE:\t %d\n", test_bit(S_TEMPERATURE, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_GEO_CONFIGURED:\t %d\n", test_bit(S_GEO_CONFIGURED, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_EXIT_PENDING:\t %d\n", test_bit(S_EXIT_PENDING, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_STATS:\t %d\n", test_bit(S_STATS, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_SCANNING:\t %d\n", test_bit(S_SCANNING, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_SCAN_ABORTING:\t %d\n", test_bit(S_SCAN_ABORTING, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_SCAN_HW:\t\t %d\n", test_bit(S_SCAN_HW, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_POWER_PMI:\t %d\n", test_bit(S_POWER_PMI, &il->status)); pos += scnprintf(buf + pos, bufsz - pos, "S_FW_ERROR:\t %d\n", test_bit(S_FW_ERROR, &il->status)); return simple_read_from_buffer(user_buf, count, ppos, buf, pos); }
static int jump__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops) { return scnprintf(bf, size, "%-6.6s %" PRIx64, ins->name, ops->target.offset); }
static ssize_t il_dbgfs_sensitivity_read(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct il_priv *il = file->private_data; int pos = 0; int cnt = 0; char *buf; int bufsz = sizeof(struct il_sensitivity_data) * 4 + 100; ssize_t ret; struct il_sensitivity_data *data; data = &il->sensitivity_data; buf = kzalloc(bufsz, GFP_KERNEL); if (!buf) { IL_ERR("Can not allocate Buffer\n"); return -ENOMEM; } pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm:\t\t\t %u\n", data->auto_corr_ofdm); pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_mrc:\t\t %u\n", data->auto_corr_ofdm_mrc); pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_x1:\t\t %u\n", data->auto_corr_ofdm_x1); pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_mrc_x1:\t\t %u\n", data->auto_corr_ofdm_mrc_x1); pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_cck:\t\t\t %u\n", data->auto_corr_cck); pos += scnprintf(buf + pos, bufsz - pos, "auto_corr_cck_mrc:\t\t %u\n", data->auto_corr_cck_mrc); pos += scnprintf(buf + pos, bufsz - pos, "last_bad_plcp_cnt_ofdm:\t\t %u\n", data->last_bad_plcp_cnt_ofdm); pos += scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_ofdm:\t\t %u\n", data->last_fa_cnt_ofdm); pos += scnprintf(buf + pos, bufsz - pos, "last_bad_plcp_cnt_cck:\t\t %u\n", data->last_bad_plcp_cnt_cck); pos += scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_cck:\t\t %u\n", data->last_fa_cnt_cck); pos += scnprintf(buf + pos, bufsz - pos, "nrg_curr_state:\t\t\t %u\n", data->nrg_curr_state); pos += scnprintf(buf + pos, bufsz - pos, "nrg_prev_state:\t\t\t %u\n", data->nrg_prev_state); pos += scnprintf(buf + pos, bufsz - pos, "nrg_value:\t\t\t"); for (cnt = 0; cnt < 10; cnt++) { pos += scnprintf(buf + pos, bufsz - pos, " %u", data->nrg_value[cnt]); } pos += scnprintf(buf + pos, bufsz - pos, "\n"); pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_rssi:\t\t"); for (cnt = 0; cnt < NRG_NUM_PREV_STAT_L; cnt++) { pos += scnprintf(buf + pos, bufsz - pos, " %u", data->nrg_silence_rssi[cnt]); } pos += scnprintf(buf + pos, bufsz - pos, "\n"); pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_ref:\t\t %u\n", data->nrg_silence_ref); pos += scnprintf(buf + pos, bufsz - pos, "nrg_energy_idx:\t\t\t %u\n", data->nrg_energy_idx); pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_idx:\t\t %u\n", data->nrg_silence_idx); pos += scnprintf(buf + pos, bufsz - pos, "nrg_th_cck:\t\t\t %u\n", data->nrg_th_cck); pos += scnprintf(buf + pos, bufsz - pos, "nrg_auto_corr_silence_diff:\t %u\n", data->nrg_auto_corr_silence_diff); pos += scnprintf(buf + pos, bufsz - pos, "num_in_cck_no_fa:\t\t %u\n", data->num_in_cck_no_fa); pos += scnprintf(buf + pos, bufsz - pos, "nrg_th_ofdm:\t\t\t %u\n", data->nrg_th_ofdm); ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); kfree(buf); return ret; }
/** * hex_dump_to_buffer - convert a blob of data to "hex ASCII" in memory * @buf: data blob to dump * @len: number of bytes in the @buf * @rowsize: number of bytes to print per line; must be 16 or 32 * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1) * @linebuf: where to put the converted data * @linebuflen: total size of @linebuf, including space for terminating NUL * @ascii: include ASCII after the hex output * * hex_dump_to_buffer() works on one "line" of output at a time, i.e., * 16 or 32 bytes of input data converted to hex + ASCII output. * * Given a buffer of u8 data, hex_dump_to_buffer() converts the input data * to a hex + ASCII dump at the supplied memory location. * The converted output is always NUL-terminated. * * E.g.: * hex_dump_to_buffer(frame->data, frame->len, 16, 1, * linebuf, sizeof(linebuf), true); * * example output buffer: * 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f @ABCDEFGHIJKLMNO */ void hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int groupsize, char *linebuf, size_t linebuflen, bool ascii) { const u8 *ptr = buf; u8 ch; int j, lx = 0; int ascii_column; if (rowsize != 16 && rowsize != 32) rowsize = 16; if (!len) goto nil; if (len > rowsize) /* limit to one line at a time */ len = rowsize; if ((len % groupsize) != 0) /* no mixed size output */ groupsize = 1; switch (groupsize) { case 8: { const u64 *ptr8 = buf; int ngroups = len / groupsize; for (j = 0; j < ngroups; j++) lx += scnprintf(linebuf + lx, linebuflen - lx, "%s%16.16llx", j ? " " : "", (unsigned long long)*(ptr8 + j)); ascii_column = 17 * ngroups + 2; break; } case 4: { const u32 *ptr4 = buf; int ngroups = len / groupsize; for (j = 0; j < ngroups; j++) lx += scnprintf(linebuf + lx, linebuflen - lx, "%s%8.8x", j ? " " : "", *(ptr4 + j)); ascii_column = 9 * ngroups + 2; break; } case 2: { const u16 *ptr2 = buf; int ngroups = len / groupsize; for (j = 0; j < ngroups; j++) lx += scnprintf(linebuf + lx, linebuflen - lx, "%s%4.4x", j ? " " : "", *(ptr2 + j)); ascii_column = 5 * ngroups + 2; break; } default: for (j = 0; (j < len) && (lx + 3) <= linebuflen; j++) { ch = ptr[j]; linebuf[lx++] = hex_asc_hi(ch); linebuf[lx++] = hex_asc_lo(ch); linebuf[lx++] = ' '; } if (j) lx--; ascii_column = 3 * rowsize + 2; break; } if (!ascii) goto nil; while (lx < (linebuflen - 1) && lx < (ascii_column - 1)) linebuf[lx++] = ' '; for (j = 0; (j < len) && (lx + 2) < linebuflen; j++) { ch = ptr[j]; linebuf[lx++] = isprint(ch) ? ch : '.'; } nil: linebuf[lx++] = '\0'; }
static ssize_t sta_agg_status_read(struct file *file, char __user *userbuf, size_t count, loff_t *ppos) { char buf[768], *p = buf; int i; struct sta_info *sta = file->private_data; p += scnprintf(p, sizeof(buf)+buf-p, "Agg state for STA is:\n"); p += scnprintf(p, sizeof(buf)+buf-p, " STA next dialog_token is %d \n " "TIDs info is: \n TID :", (sta->ampdu_mlme.dialog_token_allocator + 1)); for (i = 0; i < STA_TID_NUM; i++) p += scnprintf(p, sizeof(buf)+buf-p, "%5d", i); p += scnprintf(p, sizeof(buf)+buf-p, "\n RX :"); for (i = 0; i < STA_TID_NUM; i++) p += scnprintf(p, sizeof(buf)+buf-p, "%5d", sta->ampdu_mlme.tid_state_rx[i]); p += scnprintf(p, sizeof(buf)+buf-p, "\n DTKN:"); for (i = 0; i < STA_TID_NUM; i++) p += scnprintf(p, sizeof(buf)+buf-p, "%5d", sta->ampdu_mlme.tid_state_rx[i]? sta->ampdu_mlme.tid_rx[i]->dialog_token : 0); p += scnprintf(p, sizeof(buf)+buf-p, "\n TX :"); for (i = 0; i < STA_TID_NUM; i++) p += scnprintf(p, sizeof(buf)+buf-p, "%5d", sta->ampdu_mlme.tid_state_tx[i]); p += scnprintf(p, sizeof(buf)+buf-p, "\n DTKN:"); for (i = 0; i < STA_TID_NUM; i++) p += scnprintf(p, sizeof(buf)+buf-p, "%5d", sta->ampdu_mlme.tid_state_tx[i]? sta->ampdu_mlme.tid_tx[i]->dialog_token : 0); p += scnprintf(p, sizeof(buf)+buf-p, "\n SSN :"); for (i = 0; i < STA_TID_NUM; i++) p += scnprintf(p, sizeof(buf)+buf-p, "%5d", sta->ampdu_mlme.tid_state_tx[i]? sta->ampdu_mlme.tid_tx[i]->ssn : 0); p += scnprintf(p, sizeof(buf)+buf-p, "\n"); return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf); }
static int proc_log_enable_read(char *buffer, char **start, off_t offset, int count, int *eof, void *data) { int ret=0; if (!offset) ret = scnprintf(buffer, count, "%u\n", log_enable); return ret; }
static ssize_t acpi_pad_rrtime_show(struct device *dev, struct device_attribute *attr, char *buf) { return scnprintf(buf, PAGE_SIZE, "%d\n", round_robin_time); }
static int __init rmnet_init(void) { int ret; struct device *d; struct net_device *dev; struct rmnet_private *p; unsigned n; char *tempname; pr_info("%s: BAM devices[%d]\n", __func__, RMNET_DEVICE_COUNT); #ifdef CONFIG_MSM_RMNET_DEBUG timeout_us = 0; #ifdef CONFIG_HAS_EARLYSUSPEND timeout_suspend_us = 0; #endif #endif for (n = 0; n < RMNET_DEVICE_COUNT; n++) { dev = alloc_netdev(sizeof(struct rmnet_private), "rmnet%d", rmnet_setup); if (!dev) { pr_err("%s: no memory for netdev %d\n", __func__, n); return -ENOMEM; } netdevs[n] = dev; d = &(dev->dev); p = netdev_priv(dev); /* Initial config uses Ethernet */ p->operation_mode = RMNET_MODE_LLP_ETH; p->ch_id = n; p->waiting_for_ul_skb = NULL; p->in_reset = 0; spin_lock_init(&p->lock); spin_lock_init(&p->tx_queue_lock); #ifdef CONFIG_MSM_RMNET_DEBUG p->timeout_us = timeout_us; p->wakeups_xmit = p->wakeups_rcv = 0; #endif ret = register_netdev(dev); if (ret) { pr_err("%s: unable to register netdev" " %d rc=%d\n", __func__, n, ret); free_netdev(dev); return ret; } #ifdef CONFIG_MSM_RMNET_DEBUG if (device_create_file(d, &dev_attr_timeout)) continue; if (device_create_file(d, &dev_attr_wakeups_xmit)) continue; if (device_create_file(d, &dev_attr_wakeups_rcv)) continue; #ifdef CONFIG_HAS_EARLYSUSPEND if (device_create_file(d, &dev_attr_timeout_suspend)) continue; /* Only care about rmnet0 for suspend/resume tiemout hooks. */ if (n == 0) rmnet0 = d; #endif #endif bam_rmnet_drivers[n].probe = bam_rmnet_probe; bam_rmnet_drivers[n].remove = bam_rmnet_remove; tempname = kmalloc(BAM_DMUX_CH_NAME_MAX_LEN, GFP_KERNEL); if (tempname == NULL) return -ENOMEM; scnprintf(tempname, BAM_DMUX_CH_NAME_MAX_LEN, "bam_dmux_ch_%d", n); bam_rmnet_drivers[n].driver.name = tempname; bam_rmnet_drivers[n].driver.owner = THIS_MODULE; ret = platform_driver_register(&bam_rmnet_drivers[n]); if (ret) { pr_err("%s: registration failed n=%d rc=%d\n", __func__, n, ret); return ret; } } return 0; }
static ssize_t debug_read_status(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { struct gs_port *ui_dev = file->private_data; struct tty_struct *tty; struct gserial *gser; char *buf; unsigned long flags; int i = 0; int ret; int result = 0; tty = ui_dev->port_tty; gser = ui_dev->port_usb; buf = kzalloc(sizeof(char) * BUF_SIZE, GFP_KERNEL); if (!buf) return -ENOMEM; spin_lock_irqsave(&ui_dev->port_lock, flags); i += scnprintf(buf + i, BUF_SIZE - i, "nbytes_from_host: %lu\n", ui_dev->nbytes_from_host); i += scnprintf(buf + i, BUF_SIZE - i, "nbytes_to_tty: %lu\n", ui_dev->nbytes_to_tty); i += scnprintf(buf + i, BUF_SIZE - i, "nbytes_with_usb_OUT_txr: %lu\n", (ui_dev->nbytes_from_host - ui_dev->nbytes_to_tty)); i += scnprintf(buf + i, BUF_SIZE - i, "nbytes_from_tty: %lu\n", ui_dev->nbytes_from_tty); i += scnprintf(buf + i, BUF_SIZE - i, "nbytes_to_host: %lu\n", ui_dev->nbytes_to_host); i += scnprintf(buf + i, BUF_SIZE - i, "nbytes_with_usb_IN_txr: %lu\n", (ui_dev->nbytes_from_tty - ui_dev->nbytes_to_host)); if (tty) i += scnprintf(buf + i, BUF_SIZE - i, "tty_flags: %lu\n", tty->flags); if (gser->get_dtr) { result |= (gser->get_dtr(gser) ? TIOCM_DTR : 0); i += scnprintf(buf + i, BUF_SIZE - i, "DTR_status: %d\n", result); } i += scnprintf(buf + i, BUF_SIZE - i, "port_write_buf: %d\n", gs_buf_data_avail(&ui_dev->port_write_buf)); i += scnprintf(buf + i, BUF_SIZE - i, "write_started: %d\n", ui_dev->write_started); spin_unlock_irqrestore(&ui_dev->port_lock, flags); ret = simple_read_from_buffer(ubuf, count, ppos, buf, i); kfree(buf); return ret; }
static ssize_t il_dbgfs_chain_noise_read(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct il_priv *il = file->private_data; int pos = 0; int cnt = 0; char *buf; int bufsz = sizeof(struct il_chain_noise_data) * 4 + 100; ssize_t ret; struct il_chain_noise_data *data; data = &il->chain_noise_data; buf = kzalloc(bufsz, GFP_KERNEL); if (!buf) { IL_ERR("Can not allocate Buffer\n"); return -ENOMEM; } pos += scnprintf(buf + pos, bufsz - pos, "active_chains:\t\t\t %u\n", data->active_chains); pos += scnprintf(buf + pos, bufsz - pos, "chain_noise_a:\t\t\t %u\n", data->chain_noise_a); pos += scnprintf(buf + pos, bufsz - pos, "chain_noise_b:\t\t\t %u\n", data->chain_noise_b); pos += scnprintf(buf + pos, bufsz - pos, "chain_noise_c:\t\t\t %u\n", data->chain_noise_c); pos += scnprintf(buf + pos, bufsz - pos, "chain_signal_a:\t\t\t %u\n", data->chain_signal_a); pos += scnprintf(buf + pos, bufsz - pos, "chain_signal_b:\t\t\t %u\n", data->chain_signal_b); pos += scnprintf(buf + pos, bufsz - pos, "chain_signal_c:\t\t\t %u\n", data->chain_signal_c); pos += scnprintf(buf + pos, bufsz - pos, "beacon_count:\t\t\t %u\n", data->beacon_count); pos += scnprintf(buf + pos, bufsz - pos, "disconn_array:\t\t\t"); for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) { pos += scnprintf(buf + pos, bufsz - pos, " %u", data->disconn_array[cnt]); } pos += scnprintf(buf + pos, bufsz - pos, "\n"); pos += scnprintf(buf + pos, bufsz - pos, "delta_gain_code:\t\t"); for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) { pos += scnprintf(buf + pos, bufsz - pos, " %u", data->delta_gain_code[cnt]); } pos += scnprintf(buf + pos, bufsz - pos, "\n"); pos += scnprintf(buf + pos, bufsz - pos, "radio_write:\t\t\t %u\n", data->radio_write); pos += scnprintf(buf + pos, bufsz - pos, "state:\t\t\t\t %u\n", data->state); ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); kfree(buf); return ret; }
/** * nfs_sillyrename - Perform a silly-rename of a dentry * @dir: inode of directory that contains dentry * @dentry: dentry to be sillyrenamed * * NFSv2/3 is stateless and the server doesn't know when the client is * holding a file open. To prevent application problems when a file is * unlinked while it's still open, the client performs a "silly-rename". * That is, it renames the file to a hidden file in the same directory, * and only performs the unlink once the last reference to it is put. * * The final cleanup is done during dentry_iput. * * (Note: NFSv4 is stateful, and has opens, so in theory an NFSv4 server * could take responsibility for keeping open files referenced. The server * would also need to ensure that opened-but-deleted files were kept over * reboots. However, we may not assume a server does so. (RFC 5661 * does provide an OPEN4_RESULT_PRESERVE_UNLINKED flag that a server can * use to advertise that it does this; some day we may take advantage of * it.)) */ int nfs_sillyrename(struct inode *dir, struct dentry *dentry) { static unsigned int sillycounter; unsigned char silly[SILLYNAME_LEN + 1]; unsigned long long fileid; struct dentry *sdentry; struct rpc_task *task; int error = -EBUSY; dfprintk(VFS, "NFS: silly-rename(%pd2, ct=%d)\n", dentry, d_count(dentry)); nfs_inc_stats(dir, NFSIOS_SILLYRENAME); /* * We don't allow a dentry to be silly-renamed twice. */ if (dentry->d_flags & DCACHE_NFSFS_RENAMED) goto out; fileid = NFS_FILEID(dentry->d_inode); /* Return delegation in anticipation of the rename */ NFS_PROTO(dentry->d_inode)->return_delegation(dentry->d_inode); sdentry = NULL; do { int slen; dput(sdentry); sillycounter++; slen = scnprintf(silly, sizeof(silly), SILLYNAME_PREFIX "%0*llx%0*x", SILLYNAME_FILEID_LEN, fileid, SILLYNAME_COUNTER_LEN, sillycounter); dfprintk(VFS, "NFS: trying to rename %pd to %s\n", dentry, silly); sdentry = lookup_one_len(silly, dentry->d_parent, slen); /* * N.B. Better to return EBUSY here ... it could be * dangerous to delete the file while it's in use. */ if (IS_ERR(sdentry)) goto out; } while (sdentry->d_inode != NULL); /* need negative lookup */ /* queue unlink first. Can't do this from rpc_release as it * has to allocate memory */ error = nfs_async_unlink(dir, dentry); if (error) goto out_dput; /* populate unlinkdata with the right dname */ error = nfs_copy_dname(sdentry, (struct nfs_unlinkdata *)dentry->d_fsdata); if (error) { nfs_cancel_async_unlink(dentry); goto out_dput; } /* run the rename task, undo unlink if it fails */ task = nfs_async_rename(dir, dir, dentry, sdentry); if (IS_ERR(task)) { error = -EBUSY; nfs_cancel_async_unlink(dentry); goto out_dput; } /* wait for the RPC task to complete, unless a SIGKILL intervenes */ error = rpc_wait_for_completion_task(task); if (error == 0) error = task->tk_status; switch (error) { case 0: /* The rename succeeded */ nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); d_move(dentry, sdentry); break; case -ERESTARTSYS: /* The result of the rename is unknown. Play it safe by * forcing a new lookup */ d_drop(dentry); d_drop(sdentry); } rpc_put_task(task); out_dput: dput(sdentry); out: return error; }
static ssize_t il_dbgfs_stations_read(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct il_priv *il = file->private_data; struct il_station_entry *station; int max_sta = il->hw_params.max_stations; char *buf; int i, j, pos = 0; ssize_t ret; /* Add 30 for initial string */ const size_t bufsz = 30 + sizeof(char) * 500 * (il->num_stations); buf = kmalloc(bufsz, GFP_KERNEL); if (!buf) return -ENOMEM; pos += scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n", il->num_stations); for (i = 0; i < max_sta; i++) { station = &il->stations[i]; if (!station->used) continue; pos += scnprintf(buf + pos, bufsz - pos, "station %d - addr: %pM, flags: %#x\n", i, station->sta.sta.addr, station->sta.station_flags_msk); pos += scnprintf(buf + pos, bufsz - pos, "TID\tseq_num\ttxq_id\tframes\ttfds\t"); pos += scnprintf(buf + pos, bufsz - pos, "start_idx\tbitmap\t\t\trate_n_flags\n"); for (j = 0; j < MAX_TID_COUNT; j++) { pos += scnprintf(buf + pos, bufsz - pos, "%d:\t%#x\t%#x\t%u\t%u\t%u\t\t%#.16llx\t%#x", j, station->tid[j].seq_number, station->tid[j].agg.txq_id, station->tid[j].agg.frame_count, station->tid[j].tfds_in_queue, station->tid[j].agg.start_idx, station->tid[j].agg.bitmap, station->tid[j].agg.rate_n_flags); if (station->tid[j].agg.wait_for_ba) pos += scnprintf(buf + pos, bufsz - pos, " - waitforba"); pos += scnprintf(buf + pos, bufsz - pos, "\n"); } pos += scnprintf(buf + pos, bufsz - pos, "\n"); } ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); kfree(buf); return ret; }
static ssize_t qos_if_dls_op(const struct ieee80211_sub_if_data *sdata, char *buf, int buflen) { return scnprintf(buf, buflen, "DLS Operation: Setup = 1; Teardown = 2\n"); }
static ssize_t show_ppi_operations(char *buf, u32 start, u32 end) { char *str = buf; char version[PPI_VERSION_LEN]; acpi_handle handle; acpi_status status; struct acpi_object_list input; struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; union acpi_object params[4]; union acpi_object obj; int i; u32 ret; char *info[] = { "Not implemented", "BIOS only", "Blocked for OS by BIOS", "User required", "User not required", }; input.count = 4; ppi_assign_params(params, TPM_PPI_FN_VERSION); input.pointer = params; status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, ppi_callback, NULL, tpm_device_name, &handle); if (ACPI_FAILURE(status)) return -ENXIO; status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output, ACPI_TYPE_STRING); if (ACPI_FAILURE(status)) return -ENOMEM; strncpy(version, ((union acpi_object *)output.pointer)->string.pointer, PPI_VERSION_LEN); kfree(output.pointer); output.length = ACPI_ALLOCATE_BUFFER; output.pointer = NULL; if (strcmp(version, "1.2") == -1) return -EPERM; params[2].integer.value = TPM_PPI_FN_GETOPR; params[3].package.count = 1; obj.type = ACPI_TYPE_INTEGER; params[3].package.elements = &obj; for (i = start; i <= end; i++) { obj.integer.value = i; status = acpi_evaluate_object_typed(handle, "_DSM", &input, &output, ACPI_TYPE_INTEGER); if (ACPI_FAILURE(status)) return -ENOMEM; ret = ((union acpi_object *)output.pointer)->integer.value; if (ret > 0 && ret < ARRAY_SIZE(info)) str += scnprintf(str, PAGE_SIZE, "%d %d: %s\n", i, ret, info[ret]); kfree(output.pointer); output.length = ACPI_ALLOCATE_BUFFER; output.pointer = NULL; } return str - buf; }