ssize_t oprofilefs_str_to_user(char const *str, char __user *buf, size_t count, loff_t *offset) { return simple_read_from_buffer(buf, count, offset, str, strlen(str)); }
static ssize_t b43legacy_debugfs_read(struct file *file, char __user *userbuf, size_t count, loff_t *ppos) { struct b43legacy_wldev *dev; struct b43legacy_debugfs_fops *dfops; struct b43legacy_dfs_file *dfile; ssize_t uninitialized_var(ret); char *buf; const size_t bufsize = 1024 * 16; /* 16 KiB buffer */ const size_t buforder = get_order(bufsize); int err = 0; if (!count) return 0; dev = file->private_data; if (!dev) return -ENODEV; mutex_lock(&dev->wl->mutex); if (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED) { err = -ENODEV; goto out_unlock; } dfops = container_of(file->f_op, struct b43legacy_debugfs_fops, fops); if (!dfops->read) { err = -ENOSYS; goto out_unlock; } dfile = fops_to_dfs_file(dev, dfops); if (!dfile->buffer) { buf = (char *)__get_free_pages(GFP_KERNEL, buforder); if (!buf) { err = -ENOMEM; goto out_unlock; } memset(buf, 0, bufsize); if (dfops->take_irqlock) { spin_lock_irq(&dev->wl->irq_lock); ret = dfops->read(dev, buf, bufsize); spin_unlock_irq(&dev->wl->irq_lock); } else ret = dfops->read(dev, buf, bufsize); if (ret <= 0) { free_pages((unsigned long)buf, buforder); err = ret; goto out_unlock; } dfile->data_len = ret; dfile->buffer = buf; } ret = simple_read_from_buffer(userbuf, count, ppos, dfile->buffer, dfile->data_len); if (*ppos >= dfile->data_len) { free_pages((unsigned long)dfile->buffer, buforder); dfile->buffer = NULL; dfile->data_len = 0; } out_unlock: mutex_unlock(&dev->wl->mutex); return err ? err : ret; }
static ssize_t mtk_hdmi_debug_read(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { return simple_read_from_buffer(ubuf, count, ppos, HELP_INFO, strlen(HELP_INFO)); }
static ssize_t read_def_modal_eeprom(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { #define PR_EEP(_s, _val) \ do { \ if (pBase->opCapFlags & AR5416_OPFLAGS_11G) { \ pModal = &priv->ah->eeprom.def.modalHeader[1]; \ len += snprintf(buf + len, size - len, "%20s : %8d%7s", \ _s, (_val), "|"); \ } \ if (pBase->opCapFlags & AR5416_OPFLAGS_11A) { \ pModal = &priv->ah->eeprom.def.modalHeader[0]; \ len += snprintf(buf + len, size - len, "%9d\n", \ (_val)); \ } \ } while (0) struct ath9k_htc_priv *priv = file->private_data; struct base_eep_header *pBase = &priv->ah->eeprom.def.baseEepHeader; struct modal_eep_header *pModal = NULL; unsigned int len = 0, size = 3500; ssize_t retval = 0; char *buf; buf = kzalloc(size, GFP_KERNEL); if (buf == NULL) return -ENOMEM; len += snprintf(buf + len, size - len, "%31s %15s\n", "2G", "5G"); len += snprintf(buf + len, size - len, "%32s %16s\n", "====", "====\n"); PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]); PR_EEP("Chain1 Ant. Control", pModal->antCtrlChain[1]); PR_EEP("Chain2 Ant. Control", pModal->antCtrlChain[2]); PR_EEP("Ant. Common Control", pModal->antCtrlCommon); PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]); PR_EEP("Chain1 Ant. Gain", pModal->antennaGainCh[1]); PR_EEP("Chain2 Ant. Gain", pModal->antennaGainCh[2]); PR_EEP("Switch Settle", pModal->switchSettling); PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]); PR_EEP("Chain1 TxRxAtten", pModal->txRxAttenCh[1]); PR_EEP("Chain2 TxRxAtten", pModal->txRxAttenCh[2]); PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]); PR_EEP("Chain1 RxTxMargin", pModal->rxTxMarginCh[1]); PR_EEP("Chain2 RxTxMargin", pModal->rxTxMarginCh[2]); PR_EEP("ADC Desired size", pModal->adcDesiredSize); PR_EEP("PGA Desired size", pModal->pgaDesiredSize); PR_EEP("Chain0 xlna Gain", pModal->xlnaGainCh[0]); PR_EEP("Chain1 xlna Gain", pModal->xlnaGainCh[1]); PR_EEP("Chain2 xlna Gain", pModal->xlnaGainCh[2]); PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff); PR_EEP("txEndToRxOn", pModal->txEndToRxOn); PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn); PR_EEP("CCA Threshold)", pModal->thresh62); PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]); PR_EEP("Chain1 NF Threshold", pModal->noiseFloorThreshCh[1]); PR_EEP("Chain2 NF Threshold", pModal->noiseFloorThreshCh[2]); PR_EEP("xpdGain", pModal->xpdGain); PR_EEP("External PD", pModal->xpd); PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]); PR_EEP("Chain1 I Coefficient", pModal->iqCalICh[1]); PR_EEP("Chain2 I Coefficient", pModal->iqCalICh[2]); PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]); PR_EEP("Chain1 Q Coefficient", pModal->iqCalQCh[1]); PR_EEP("Chain2 Q Coefficient", pModal->iqCalQCh[2]); PR_EEP("pdGainOverlap", pModal->pdGainOverlap); PR_EEP("Chain0 OutputBias", pModal->ob); PR_EEP("Chain0 DriverBias", pModal->db); PR_EEP("xPA Bias Level", pModal->xpaBiasLvl); PR_EEP("2chain pwr decrease", pModal->pwrDecreaseFor2Chain); PR_EEP("3chain pwr decrease", pModal->pwrDecreaseFor3Chain); PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart); PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn); PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc); PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]); PR_EEP("Chain1 bswAtten", pModal->bswAtten[1]); PR_EEP("Chain2 bswAtten", pModal->bswAtten[2]); PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]); PR_EEP("Chain1 bswMargin", pModal->bswMargin[1]); PR_EEP("Chain2 bswMargin", pModal->bswMargin[2]); PR_EEP("HT40 Switch Settle", pModal->swSettleHt40); PR_EEP("Chain0 xatten2Db", pModal->xatten2Db[0]); PR_EEP("Chain1 xatten2Db", pModal->xatten2Db[1]); PR_EEP("Chain2 xatten2Db", pModal->xatten2Db[2]); PR_EEP("Chain0 xatten2Margin", pModal->xatten2Margin[0]); PR_EEP("Chain1 xatten2Margin", pModal->xatten2Margin[1]); PR_EEP("Chain2 xatten2Margin", pModal->xatten2Margin[2]); PR_EEP("Chain1 OutputBias", pModal->ob_ch1); PR_EEP("Chain1 DriverBias", pModal->db_ch1); PR_EEP("LNA Control", pModal->lna_ctl); PR_EEP("XPA Bias Freq0", pModal->xpaBiasLvlFreq[0]); PR_EEP("XPA Bias Freq1", pModal->xpaBiasLvlFreq[1]); PR_EEP("XPA Bias Freq2", pModal->xpaBiasLvlFreq[2]); if (len > size) len = size; retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); kfree(buf); return retval; #undef PR_EEP }
static ssize_t read_9287_modal_eeprom(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { #define PR_EEP(_s, _val) \ do { \ len += snprintf(buf + len, size - len, "%20s : %10d\n", \ _s, (_val)); \ } while (0) struct ath9k_htc_priv *priv = file->private_data; struct modal_eep_ar9287_header *pModal = &priv->ah->eeprom.map9287.modalHeader; unsigned int len = 0, size = 3000; ssize_t retval = 0; char *buf; buf = kzalloc(size, GFP_KERNEL); if (buf == NULL) return -ENOMEM; PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]); PR_EEP("Chain1 Ant. Control", pModal->antCtrlChain[1]); PR_EEP("Ant. Common Control", pModal->antCtrlCommon); PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]); PR_EEP("Chain1 Ant. Gain", pModal->antennaGainCh[1]); PR_EEP("Switch Settle", pModal->switchSettling); PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]); PR_EEP("Chain1 TxRxAtten", pModal->txRxAttenCh[1]); PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]); PR_EEP("Chain1 RxTxMargin", pModal->rxTxMarginCh[1]); PR_EEP("ADC Desired size", pModal->adcDesiredSize); PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff); PR_EEP("txEndToRxOn", pModal->txEndToRxOn); PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn); PR_EEP("CCA Threshold)", pModal->thresh62); PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]); PR_EEP("Chain1 NF Threshold", pModal->noiseFloorThreshCh[1]); PR_EEP("xpdGain", pModal->xpdGain); PR_EEP("External PD", pModal->xpd); PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]); PR_EEP("Chain1 I Coefficient", pModal->iqCalICh[1]); PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]); PR_EEP("Chain1 Q Coefficient", pModal->iqCalQCh[1]); PR_EEP("pdGainOverlap", pModal->pdGainOverlap); PR_EEP("xPA Bias Level", pModal->xpaBiasLvl); PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart); PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn); PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc); PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]); PR_EEP("Chain1 bswAtten", pModal->bswAtten[1]); PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]); PR_EEP("Chain1 bswMargin", pModal->bswMargin[1]); PR_EEP("HT40 Switch Settle", pModal->swSettleHt40); PR_EEP("AR92x7 Version", pModal->version); PR_EEP("DriverBias1", pModal->db1); PR_EEP("DriverBias2", pModal->db1); PR_EEP("CCK OutputBias", pModal->ob_cck); PR_EEP("PSK OutputBias", pModal->ob_psk); PR_EEP("QAM OutputBias", pModal->ob_qam); PR_EEP("PAL_OFF OutputBias", pModal->ob_pal_off); if (len > size) len = size; retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); kfree(buf); return retval; #undef PR_EEP }
ssize_t on_cmd_read(struct file *filp, char __user *user_buf, size_t count, loff_t *ppos) { int ret; int i, j; char *buf; int buf_size; struct dsi_panel_cmds *pcmds; struct mdss_panel_common_pdata *panel_data = filp->private_data; if (!panel_data) return -ENODEV; pcmds = &panel_data->on_cmds; if (!pcmds) return -EINVAL; buf = kzalloc(MAX_ON_CMD_SIZE, GFP_KERNEL); strncpy(buf, "qcom,panel-on-cmds = [", 22); buf_size = 22; for (i = 0; i < pcmds->cmd_cnt; ++i) { if (buf_size + 20 + (pcmds->cmds[i].dchdr.dlen * 3) > MAX_ON_CMD_SIZE - 4) { pr_warn("Too many on_commands!(< 32KB)\n"); ret = -EINVAL; goto read_error; } strncpy(&buf[buf_size], "\r\n", 2); buf_size += 2; ret = snprintf(&buf[buf_size], 21, "%02x %02x %02x %02x %02x %02x %02x", pcmds->cmds[i].dchdr.dtype, pcmds->cmds[i].dchdr.last, pcmds->cmds[i].dchdr.vc, pcmds->cmds[i].dchdr.ack, pcmds->cmds[i].dchdr.wait, (char)(pcmds->cmds[i].dchdr.dlen & 0xff00) >> 8, (char)(pcmds->cmds[i].dchdr.dlen & 0x00ff)); if (ret < 0) goto read_error; buf_size += ret; if (0 < pcmds->cmds[i].dchdr.dlen && pcmds->cmds[i].dchdr.dlen < 3) { ret = snprintf(&buf[buf_size], 4, " %02x", pcmds->cmds[i].payload[0]); if (ret < 0) goto read_error; buf_size += ret; if (pcmds->cmds[i].dchdr.dlen == 2) { ret = snprintf(&buf[buf_size], 4, " %02x", pcmds->cmds[i].payload[1]); if (ret < 0) goto read_error; buf_size += ret; } } else if (pcmds->cmds[i].dchdr.dlen > 2) { for (j = 0; j < pcmds->cmds[i].dchdr.dlen; ++j) { if ((j % 6) == 0) { ret = snprintf(&buf[buf_size], 5, "\r\n%02x", pcmds->cmds[i].payload[j]); if (ret < 0) goto read_error; buf_size += ret; } else { ret = snprintf(&buf[buf_size], 4, " %02x", pcmds->cmds[i].payload[j]); if (ret < 0) goto read_error; buf_size += ret; } } } else { pr_err("Invalid data length!\n"); ret = -EINVAL; goto read_error; } } strncpy(&buf[buf_size], "]", 2); buf_size += 2; ret = simple_read_from_buffer(user_buf, count, ppos, buf, buf_size); read_error: kfree(buf); return ret; }
static ssize_t read_file_base_eeprom(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct ath9k_htc_priv *priv = file->private_data; struct ath_common *common = ath9k_hw_common(priv->ah); struct base_eep_header *pBase = NULL; unsigned int len = 0, size = 1500; ssize_t retval = 0; char *buf; /* * This can be done since all the 3 EEPROM families have the * same base header upto a certain point, and we are interested in * the data only upto that point. */ if (AR_SREV_9271(priv->ah)) pBase = (struct base_eep_header *) &priv->ah->eeprom.map4k.baseEepHeader; else if (priv->ah->hw_version.usbdev == AR9280_USB) pBase = (struct base_eep_header *) &priv->ah->eeprom.def.baseEepHeader; else if (priv->ah->hw_version.usbdev == AR9287_USB) pBase = (struct base_eep_header *) &priv->ah->eeprom.map9287.baseEepHeader; if (pBase == NULL) { ath_err(common, "Unknown EEPROM type\n"); return 0; } buf = kzalloc(size, GFP_KERNEL); if (buf == NULL) return -ENOMEM; len += snprintf(buf + len, size - len, "%20s : %10d\n", "Major Version", pBase->version >> 12); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Minor Version", pBase->version & 0xFFF); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Checksum", pBase->checksum); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Length", pBase->length); len += snprintf(buf + len, size - len, "%20s : %10d\n", "RegDomain1", pBase->regDmn[0]); len += snprintf(buf + len, size - len, "%20s : %10d\n", "RegDomain2", pBase->regDmn[1]); len += snprintf(buf + len, size - len, "%20s : %10d\n", "TX Mask", pBase->txMask); len += snprintf(buf + len, size - len, "%20s : %10d\n", "RX Mask", pBase->rxMask); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Allow 5GHz", !!(pBase->opCapFlags & AR5416_OPFLAGS_11A)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Allow 2GHz", !!(pBase->opCapFlags & AR5416_OPFLAGS_11G)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Disable 2GHz HT20", !!(pBase->opCapFlags & AR5416_OPFLAGS_N_2G_HT20)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Disable 2GHz HT40", !!(pBase->opCapFlags & AR5416_OPFLAGS_N_2G_HT40)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Disable 5Ghz HT20", !!(pBase->opCapFlags & AR5416_OPFLAGS_N_5G_HT20)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Disable 5Ghz HT40", !!(pBase->opCapFlags & AR5416_OPFLAGS_N_5G_HT40)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Big Endian", !!(pBase->eepMisc & 0x01)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Cal Bin Major Ver", (pBase->binBuildNumber >> 24) & 0xFF); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Cal Bin Minor Ver", (pBase->binBuildNumber >> 16) & 0xFF); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Cal Bin Build", (pBase->binBuildNumber >> 8) & 0xFF); /* * UB91 specific data. */ if (AR_SREV_9271(priv->ah)) { struct base_eep_header_4k *pBase4k = &priv->ah->eeprom.map4k.baseEepHeader; len += snprintf(buf + len, size - len, "%20s : %10d\n", "TX Gain type", pBase4k->txGainType); } /* * UB95 specific data. */ if (priv->ah->hw_version.usbdev == AR9287_USB) { struct base_eep_ar9287_header *pBase9287 = &priv->ah->eeprom.map9287.baseEepHeader; len += snprintf(buf + len, size - len, "%20s : %10ddB\n", "Power Table Offset", pBase9287->pwrTableOffset); len += snprintf(buf + len, size - len, "%20s : %10d\n", "OpenLoop Power Ctrl", pBase9287->openLoopPwrCntl); } len += snprintf(buf + len, size - len, "%20s : %pM\n", "MacAddress", pBase->macAddr); if (len > size) len = size; retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); kfree(buf); return retval; }
static ssize_t diag_dbgfs_read_table(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { char *buf; int ret = 0; int i; int bytes_remaining; int bytes_in_buffer = 0; int bytes_written; int buf_size = (DEBUG_BUF_SIZE < count) ? DEBUG_BUF_SIZE : count; if (diag_dbgfs_table_index >= diag_max_reg) { /* Done. Reset to prepare for future requests */ diag_dbgfs_table_index = 0; return 0; } buf = kzalloc(sizeof(char) * buf_size, GFP_KERNEL); if (ZERO_OR_NULL_PTR(buf)) { pr_err("diag: %s, Error allocating memory\n", __func__); return -ENOMEM; } bytes_remaining = buf_size; if (diag_dbgfs_table_index == 0) { bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining, "Client ids: Modem: %d, LPASS: %d, " "WCNSS: %d, APPS: %d\n", MODEM_DATA, LPASS_DATA, WCNSS_DATA, APPS_DATA); bytes_in_buffer += bytes_written; } for (i = diag_dbgfs_table_index; i < diag_max_reg; i++) { /* Do not process empty entries in the table */ if (driver->table[i].process_id == 0) continue; bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining, "i: %3d, cmd_code: %4x, subsys_id: %4x, " "client: %2d, cmd_code_lo: %4x, " "cmd_code_hi: %4x, process_id: %5d %s\n", i, driver->table[i].cmd_code, driver->table[i].subsys_id, driver->table[i].client_id, driver->table[i].cmd_code_lo, driver->table[i].cmd_code_hi, driver->table[i].process_id, (diag_find_polling_reg(i) ? "<- Polling cmd reg" : "")); bytes_in_buffer += bytes_written; /* Check if there is room to add another table entry */ bytes_remaining = buf_size - bytes_in_buffer; if (bytes_remaining < bytes_written) break; } diag_dbgfs_table_index = i+1; *ppos = 0; ret = simple_read_from_buffer(ubuf, count, ppos, buf, bytes_in_buffer); kfree(buf); return ret; }
static ssize_t diag_dbgfs_read_mempool(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { char *buf = NULL; int ret = 0, i = 0; buf = kzalloc(sizeof(char) * DEBUG_BUF_SIZE, GFP_KERNEL); if (ZERO_OR_NULL_PTR(buf)) { pr_err("diag: %s, Error allocating memory\n", __func__); return -ENOMEM; } ret = scnprintf(buf, DEBUG_BUF_SIZE, "POOL_TYPE_COPY: [0x%p : 0x%p] count = %d\n" "POOL_TYPE_HDLC: [0x%p : 0x%p] count = %d\n" "POOL_TYPE_USER: [0x%p : 0x%p] count = %d\n" "POOL_TYPE_WRITE_STRUCT: [0x%p : 0x%p] count = %d\n" "POOL_TYPE_DCI: [0x%p : 0x%p] count = %d\n", driver->diagpool, diag_pools_array[POOL_COPY_IDX], driver->count, driver->diag_hdlc_pool, diag_pools_array[POOL_HDLC_IDX], driver->count_hdlc_pool, driver->diag_user_pool, diag_pools_array[POOL_USER_IDX], driver->count_user_pool, driver->diag_write_struct_pool, diag_pools_array[POOL_WRITE_STRUCT_IDX], driver->count_write_struct_pool, driver->diag_dci_pool, diag_pools_array[POOL_DCI_IDX], driver->count_dci_pool); for (i = 0; i < MAX_HSIC_CH; i++) { if (!diag_hsic[i].hsic_inited) continue; ret += scnprintf(buf+ret, DEBUG_BUF_SIZE-ret, "POOL_TYPE_HSIC_%d: [0x%p : 0x%p] count = %d\n", i+1, diag_hsic[i].diag_hsic_pool, diag_pools_array[POOL_HSIC_IDX + i], diag_hsic[i].count_hsic_pool); } for (i = 0; i < MAX_HSIC_CH; i++) { if (!diag_hsic[i].hsic_inited) continue; ret += scnprintf(buf+ret, DEBUG_BUF_SIZE-ret, "POOL_TYPE_HSIC_%d_WRITE: [0x%p : 0x%p] count = %d\n", i+1, diag_hsic[i].diag_hsic_write_pool, diag_pools_array[POOL_HSIC_WRITE_IDX + i], diag_hsic[i].count_hsic_write_pool); } ret = simple_read_from_buffer(ubuf, count, ppos, buf, ret); kfree(buf); return ret; }
static ssize_t diag_dbgfs_read_workpending(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { char *buf; int ret; buf = kzalloc(sizeof(char) * DEBUG_BUF_SIZE, GFP_KERNEL); if (!buf) { pr_err("diag: %s, Error allocating memory\n", __func__); return -ENOMEM; } ret = scnprintf(buf, DEBUG_BUF_SIZE, "Pending status for work_stucts:\n" "diag_drain_work: %d\n" "Modem data diag_read_smd_work: %d\n" "LPASS data diag_read_smd_work: %d\n" "RIVA data diag_read_smd_work: %d\n" "Modem cntl diag_read_smd_work: %d\n" "LPASS cntl diag_read_smd_work: %d\n" "RIVA cntl diag_read_smd_work: %d\n" "Modem dci diag_read_smd_work: %d\n" "Modem data diag_notify_update_smd_work: %d\n" "LPASS data diag_notify_update_smd_work: %d\n" "RIVA data diag_notify_update_smd_work: %d\n" "Modem cntl diag_notify_update_smd_work: %d\n" "LPASS cntl diag_notify_update_smd_work: %d\n" "RIVA cntl diag_notify_update_smd_work: %d\n" "Modem dci diag_notify_update_smd_work: %d\n", work_pending(&(driver->diag_drain_work)), work_pending(&(driver->smd_data[MODEM_DATA]. diag_read_smd_work)), work_pending(&(driver->smd_data[LPASS_DATA]. diag_read_smd_work)), work_pending(&(driver->smd_data[WCNSS_DATA]. diag_read_smd_work)), work_pending(&(driver->smd_cntl[MODEM_DATA]. diag_read_smd_work)), work_pending(&(driver->smd_cntl[LPASS_DATA]. diag_read_smd_work)), work_pending(&(driver->smd_cntl[WCNSS_DATA]. diag_read_smd_work)), work_pending(&(driver->smd_dci[MODEM_DATA]. diag_read_smd_work)), work_pending(&(driver->smd_data[MODEM_DATA]. diag_notify_update_smd_work)), work_pending(&(driver->smd_data[LPASS_DATA]. diag_notify_update_smd_work)), work_pending(&(driver->smd_data[WCNSS_DATA]. diag_notify_update_smd_work)), work_pending(&(driver->smd_cntl[MODEM_DATA]. diag_notify_update_smd_work)), work_pending(&(driver->smd_cntl[LPASS_DATA]. diag_notify_update_smd_work)), work_pending(&(driver->smd_cntl[WCNSS_DATA]. diag_notify_update_smd_work)), work_pending(&(driver->smd_dci[MODEM_DATA]. diag_notify_update_smd_work))); #ifdef CONFIG_DIAG_OVER_USB ret += scnprintf(buf+ret, DEBUG_BUF_SIZE, "diag_proc_hdlc_work: %d\n" "diag_read_work: %d\n", work_pending(&(driver->diag_proc_hdlc_work)), work_pending(&(driver->diag_read_work))); #endif ret = simple_read_from_buffer(ubuf, count, ppos, buf, ret); kfree(buf); return ret; }
static ssize_t diag_dbgfs_read_status(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { char *buf; int ret; buf = kzalloc(sizeof(char) * DEBUG_BUF_SIZE, GFP_KERNEL); if (!buf) { pr_err("diag: %s, Error allocating memory\n", __func__); return -ENOMEM; } ret = scnprintf(buf, DEBUG_BUF_SIZE, "modem ch: 0x%x\n" "lpass ch: 0x%x\n" "riva ch: 0x%x\n" "dci ch: 0x%x\n" "modem cntl_ch: 0x%x\n" "lpass cntl_ch: 0x%x\n" "riva cntl_ch: 0x%x\n" "modem cmd ch: 0x%x\n" "dci cmd ch: 0x%x\n" "CPU Tools id: %d\n" "Apps only: %d\n" "Apps master: %d\n" "Check Polling Response: %d\n" "polling_reg_flag: %d\n" "uses device tree: %d\n" "supports separate cmdrsp: %d\n" "Modem separate cmdrsp: %d\n" "LPASS separate cmdrsp: %d\n" "RIVA separate cmdrsp: %d\n" "Modem in_busy_1: %d\n" "Modem in_busy_2: %d\n" "LPASS in_busy_1: %d\n" "LPASS in_busy_2: %d\n" "RIVA in_busy_1: %d\n" "RIVA in_busy_2: %d\n" "DCI Modem in_busy_1: %d\n" "Modem CMD in_busy_1: %d\n" "Modem CMD in_busy_2: %d\n" "DCI CMD Modem in_busy_1: %d\n" "Modem supports STM: %d\n" "LPASS supports STM: %d\n" "RIVA supports STM: %d\n" "Modem STM state: %d\n" "LPASS STM state: %d\n" "RIVA STM state: %d\n" "APPS STM state: %d\n" "Modem STM requested state: %d\n" "LPASS STM requested state: %d\n" "RIVA STM requested state: %d\n" "APPS STM requested state: %d\n" "supports apps hdlc encoding: %d\n" "Modem hdlc encoding: %d\n" "Lpass hdlc encoding: %d\n" "RIVA hdlc encoding: %d\n" "Modem CMD hdlc encoding: %d\n" "Modem DATA in_buf_1_size: %d\n" "Modem DATA in_buf_2_size: %d\n" "ADSP DATA in_buf_1_size: %d\n" "ADSP DATA in_buf_2_size: %d\n" "RIVA DATA in_buf_1_size: %d\n" "RIVA DATA in_buf_2_size: %d\n" "Modem DATA in_buf_1_raw_size: %d\n" "Modem DATA in_buf_2_raw_size: %d\n" "ADSP DATA in_buf_1_raw_size: %d\n" "ADSP DATA in_buf_2_raw_size: %d\n" "RIVA DATA in_buf_1_raw_size: %d\n" "RIVA DATA in_buf_2_raw_size: %d\n" "Modem CMD in_buf_1_size: %d\n" "Modem CMD in_buf_1_raw_size: %d\n" "Modem CNTL in_buf_1_size: %d\n" "ADSP CNTL in_buf_1_size: %d\n" "RIVA CNTL in_buf_1_size: %d\n" "Modem DCI in_buf_1_size: %d\n" "Modem DCI CMD in_buf_1_size: %d\n" "logging_mode: %d\n" "real_time_mode: %d\n", (unsigned int)driver->smd_data[MODEM_DATA].ch, (unsigned int)driver->smd_data[LPASS_DATA].ch, (unsigned int)driver->smd_data[WCNSS_DATA].ch, (unsigned int)driver->smd_dci[MODEM_DATA].ch, (unsigned int)driver->smd_cntl[MODEM_DATA].ch, (unsigned int)driver->smd_cntl[LPASS_DATA].ch, (unsigned int)driver->smd_cntl[WCNSS_DATA].ch, (unsigned int)driver->smd_cmd[MODEM_DATA].ch, (unsigned int)driver->smd_dci_cmd[MODEM_DATA].ch, chk_config_get_id(), chk_apps_only(), chk_apps_master(), chk_polling_response(), driver->polling_reg_flag, driver->use_device_tree, driver->supports_separate_cmdrsp, driver->separate_cmdrsp[MODEM_DATA], driver->separate_cmdrsp[LPASS_DATA], driver->separate_cmdrsp[WCNSS_DATA], driver->smd_data[MODEM_DATA].in_busy_1, driver->smd_data[MODEM_DATA].in_busy_2, driver->smd_data[LPASS_DATA].in_busy_1, driver->smd_data[LPASS_DATA].in_busy_2, driver->smd_data[WCNSS_DATA].in_busy_1, driver->smd_data[WCNSS_DATA].in_busy_2, driver->smd_dci[MODEM_DATA].in_busy_1, driver->smd_cmd[MODEM_DATA].in_busy_1, driver->smd_cmd[MODEM_DATA].in_busy_2, driver->smd_dci_cmd[MODEM_DATA].in_busy_1, driver->peripheral_supports_stm[MODEM_DATA], driver->peripheral_supports_stm[LPASS_DATA], driver->peripheral_supports_stm[WCNSS_DATA], driver->stm_state[MODEM_DATA], driver->stm_state[LPASS_DATA], driver->stm_state[WCNSS_DATA], driver->stm_state[APPS_DATA], driver->stm_state_requested[MODEM_DATA], driver->stm_state_requested[LPASS_DATA], driver->stm_state_requested[WCNSS_DATA], driver->stm_state_requested[APPS_DATA], driver->supports_apps_hdlc_encoding, driver->smd_data[MODEM_DATA].encode_hdlc, driver->smd_data[LPASS_DATA].encode_hdlc, driver->smd_data[WCNSS_DATA].encode_hdlc, driver->smd_cmd[MODEM_DATA].encode_hdlc, (unsigned int)driver->smd_data[MODEM_DATA].buf_in_1_size, (unsigned int)driver->smd_data[MODEM_DATA].buf_in_2_size, (unsigned int)driver->smd_data[LPASS_DATA].buf_in_1_size, (unsigned int)driver->smd_data[LPASS_DATA].buf_in_2_size, (unsigned int)driver->smd_data[WCNSS_DATA].buf_in_1_size, (unsigned int)driver->smd_data[WCNSS_DATA].buf_in_2_size, (unsigned int)driver->smd_data[MODEM_DATA].buf_in_1_raw_size, (unsigned int)driver->smd_data[MODEM_DATA].buf_in_2_raw_size, (unsigned int)driver->smd_data[LPASS_DATA].buf_in_1_raw_size, (unsigned int)driver->smd_data[LPASS_DATA].buf_in_2_raw_size, (unsigned int)driver->smd_data[WCNSS_DATA].buf_in_1_raw_size, (unsigned int)driver->smd_data[WCNSS_DATA].buf_in_2_raw_size, (unsigned int)driver->smd_cmd[MODEM_DATA].buf_in_1_size, (unsigned int)driver->smd_cmd[MODEM_DATA].buf_in_1_raw_size, (unsigned int)driver->smd_cntl[MODEM_DATA].buf_in_1_size, (unsigned int)driver->smd_cntl[LPASS_DATA].buf_in_1_size, (unsigned int)driver->smd_cntl[WCNSS_DATA].buf_in_1_size, (unsigned int)driver->smd_dci[MODEM_DATA].buf_in_1_size, (unsigned int)driver->smd_dci_cmd[MODEM_DATA].buf_in_1_size, driver->logging_mode, driver->real_time_mode); #ifdef CONFIG_DIAG_OVER_USB ret += scnprintf(buf+ret, DEBUG_BUF_SIZE, "usb_connected: %d\n", driver->usb_connected); #endif ret = simple_read_from_buffer(ubuf, count, ppos, buf, ret); kfree(buf); return ret; }
static ssize_t diag_dbgfs_read_dcistats(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { char *buf = NULL; int bytes_remaining, bytes_written = 0, bytes_in_buf = 0, i = 0; struct diag_dci_data_info *temp_data = dci_data_smd; int buf_size = (DEBUG_BUF_SIZE < count) ? DEBUG_BUF_SIZE : count; if (diag_dbgfs_dci_finished) { diag_dbgfs_dci_finished = 0; return 0; } buf = kzalloc(sizeof(char) * buf_size, GFP_KERNEL); if (ZERO_OR_NULL_PTR(buf)) { pr_err("diag: %s, Error allocating memory\n", __func__); return -ENOMEM; } bytes_remaining = buf_size; if (diag_dbgfs_dci_data_index == 0) { bytes_written = scnprintf(buf, buf_size, "number of clients: %d\n" "dci proc active: %d\n" "dci real time vote: %d\n", driver->num_dci_client, (driver->proc_active_mask & DIAG_PROC_DCI) ? 1 : 0, (driver->proc_rt_vote_mask & DIAG_PROC_DCI) ? 1 : 0); bytes_in_buf += bytes_written; bytes_remaining -= bytes_written; #ifdef CONFIG_DIAG_OVER_USB bytes_written = scnprintf(buf+bytes_in_buf, bytes_remaining, "usb_connected: %d\n", driver->usb_connected); bytes_in_buf += bytes_written; bytes_remaining -= bytes_written; #endif if (driver->dci_device) { bytes_written = scnprintf(buf+bytes_in_buf, bytes_remaining, "dci power active, relax: %lu, %lu\n", driver->dci_device->power.wakeup->active_count, driver->dci_device->power.wakeup->relax_count); bytes_in_buf += bytes_written; bytes_remaining -= bytes_written; } if (driver->dci_cmd_device) { bytes_written = scnprintf(buf+bytes_in_buf, bytes_remaining, "dci cmd power active, relax: %lu, %lu\n", driver->dci_cmd_device->power.wakeup-> active_count, driver->dci_cmd_device->power.wakeup-> relax_count); bytes_in_buf += bytes_written; bytes_remaining -= bytes_written; } } temp_data += diag_dbgfs_dci_data_index; for (i = diag_dbgfs_dci_data_index; i < DIAG_DCI_DEBUG_CNT; i++) { if (temp_data->iteration != 0) { bytes_written = scnprintf( buf + bytes_in_buf, bytes_remaining, "i %-10ld\t" "s %-10d\t" "c %-10d\t" "t %-15s\n", temp_data->iteration, temp_data->data_size, temp_data->ch_type, temp_data->time_stamp); bytes_in_buf += bytes_written; bytes_remaining -= bytes_written; /* Check if there is room for another entry */ if (bytes_remaining < bytes_written) break; } temp_data++; } diag_dbgfs_dci_data_index = (i >= DIAG_DCI_DEBUG_CNT) ? 0 : i + 1; bytes_written = simple_read_from_buffer(ubuf, count, ppos, buf, bytes_in_buf); kfree(buf); diag_dbgfs_dci_finished = 1; return bytes_written; }
static ssize_t max17047_debugfs_read_registers(struct file *filp, char __user *buffer, size_t count, loff_t *ppos) { struct max17047_fuelgauge_data *fuelgauge_data = filp->private_data; struct i2c_client *client = NULL; u8 i2c_data[2]; int reg = 0; char *buf; size_t len = 0; ssize_t ret; if (!fuelgauge_data) { pr_err("%s : fuelgauge_data is null\n", __func__); return 0; } client = fuelgauge_data->client; if (*ppos != 0) return 0; if (count < sizeof(buf)) return -ENOSPC; buf = kzalloc(PAGE_SIZE, GFP_KERNEL); if (!buf) return -ENOMEM; reg = MAX17047_REG_STATUS; max17047_i2c_read(client, reg, i2c_data); len += snprintf(buf + len, PAGE_SIZE - len, "status(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); reg = MAX17047_REG_CONFIG; max17047_i2c_read(client, reg, i2c_data); len += snprintf(buf + len, PAGE_SIZE - len, "config(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); reg = MAX17047_REG_RCOMP; max17047_i2c_read(client, reg, i2c_data); len += snprintf(buf + len, PAGE_SIZE - len, "rcomp(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); reg = MAX17047_REG_CGAIN; max17047_i2c_read(client, reg, i2c_data); len += snprintf(buf + len, PAGE_SIZE - len, "cgain(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); reg = MAX17047_REG_SALRT_TH; max17047_i2c_read(client, reg, i2c_data); len += snprintf(buf + len, PAGE_SIZE - len, "salrt(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); reg = MAX17047_REG_MISCCFG; max17047_i2c_read(client, reg, i2c_data); len += snprintf(buf + len, PAGE_SIZE - len, "misc(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); reg = 0x39; max17047_i2c_read(client, reg, i2c_data); len += snprintf(buf + len, PAGE_SIZE - len, "tempc0(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); reg = 0x0F; max17047_i2c_read(client, reg, i2c_data); len += snprintf(buf + len, PAGE_SIZE - len, "remCap(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); reg = 0x10; max17047_i2c_read(client, reg, i2c_data); len += snprintf(buf + len, PAGE_SIZE - len, "fullCap(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); len += snprintf(buf + len, PAGE_SIZE - len, "\n"); ret = simple_read_from_buffer(buffer, len, ppos, buf, PAGE_SIZE); kfree(buf); return ret; }
static ssize_t power_power_events_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos) { return simple_read_from_buffer(ubuf, cnt, ppos, pwr_buf, POWER_BUFFER_SIZE); }
static ssize_t rtc_getdevice_dbg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) { int n = 0; static char *buffer; static char *swap_buf; const int debug_bufmax = 1024; int swap_count = 0; int rc = 0; int dev_count = 0; int dev_id = 0; struct msm_cad_endpoints *msm_cad_epts = the_snd.cad_epts; struct cad_endpoint *cad_epts; buffer = kmalloc(sizeof(char) * 1024, GFP_KERNEL); if (buffer == NULL) { MM_ERR("Memory allocation failed for buffer failed\n"); return -EFAULT; } swap_buf = kmalloc(sizeof(char) * 1024, GFP_KERNEL); if (swap_buf == NULL) { MM_ERR("Memory allocation failed for swap buffer failed\n"); kfree(buffer); return -EFAULT; } if (msm_cad_epts->num <= 0) { dev_count = 0; n = scnprintf(buffer, debug_bufmax, "DEV_NO:0x%x\n", msm_cad_epts->num); } else { for (dev_id = 0; dev_id < msm_cad_epts->num; dev_id++) { cad_epts = &msm_cad_epts->endpoints[dev_id]; if (IS_ERR(cad_epts)) { MM_ERR("invalid snd endpoint for dev_id %d\n", dev_id); rc = PTR_ERR(cad_epts); continue; } if ((cad_epts->id != curr_dev.tx_dev) && (cad_epts->id != curr_dev.rx_dev)) continue; n += scnprintf(swap_buf + n, debug_bufmax - n, "ACDB_ID:0x%x;CAPB:0x%x\n", cad_epts->id, cad_epts->capability); dev_count++; MM_DBG("RTC Get Device %x Capb %x Dev Count %x\n", dev_id, cad_epts->capability, dev_count); } } swap_count = scnprintf(buffer, debug_bufmax, \ "DEV_NO:0x%x\n", dev_count); memcpy(buffer+swap_count, swap_buf, n*sizeof(char)); n = n+swap_count; buffer[n] = 0; rc = simple_read_from_buffer(buf, count, ppos, buffer, n); kfree(buffer); kfree(swap_buf); return rc; }
static ssize_t diag_dbgfs_read_bridge(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { char *buf; int ret; int i; int bytes_remaining; int bytes_in_buffer = 0; int bytes_written; int buf_size = (DEBUG_BUF_SIZE < count) ? DEBUG_BUF_SIZE : count; int bytes_hsic_inited = 45; int bytes_hsic_not_inited = 410; if (diag_dbgfs_finished) { diag_dbgfs_finished = 0; return 0; } buf = kzalloc(sizeof(char) * buf_size, GFP_KERNEL); if (ZERO_OR_NULL_PTR(buf)) { pr_err("diag: %s, Error allocating memory\n", __func__); return -ENOMEM; } bytes_remaining = buf_size; /* Only one smux for now */ bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining, "Values for SMUX instance: 0\n" "smux ch: %d\n" "smux enabled %d\n" "smux in busy %d\n" "smux connected %d\n\n", driver->lcid, driver->diag_smux_enabled, driver->in_busy_smux, driver->smux_connected); bytes_in_buffer += bytes_written; bytes_remaining = buf_size - bytes_in_buffer; bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining, "HSIC diag_disconnect_work: %d\n", work_pending(&(driver->diag_disconnect_work))); bytes_in_buffer += bytes_written; bytes_remaining = buf_size - bytes_in_buffer; for (i = 0; i < MAX_HSIC_CH; i++) { if (diag_hsic[i].hsic_inited) { /* Check if there is room to add another HSIC entry */ if (bytes_remaining < bytes_hsic_inited) break; bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining, "Values for HSIC Instance: %d\n" "hsic ch: %d\n" "hsic_inited: %d\n" "hsic enabled: %d\n" "hsic_opened: %d\n" "hsic_suspend: %d\n" "in_busy_hsic_read_on_device: %d\n" "in_busy_hsic_write: %d\n" "count_hsic_pool: %d\n" "count_hsic_write_pool: %d\n" "diag_hsic_pool: %x\n" "diag_hsic_write_pool: %x\n" "HSIC write_len: %d\n" "num_hsic_buf_tbl_entries: %d\n" "HSIC usb_connected: %d\n" "HSIC diag_read_work: %d\n" "diag_read_hsic_work: %d\n" "diag_usb_read_complete_work: %d\n\n", i, diag_hsic[i].hsic_ch, diag_hsic[i].hsic_inited, diag_hsic[i].hsic_device_enabled, diag_hsic[i].hsic_device_opened, diag_hsic[i].hsic_suspend, diag_hsic[i].in_busy_hsic_read_on_device, diag_hsic[i].in_busy_hsic_write, diag_hsic[i].count_hsic_pool, diag_hsic[i].count_hsic_write_pool, (unsigned int)diag_hsic[i].diag_hsic_pool, (unsigned int)diag_hsic[i].diag_hsic_write_pool, diag_bridge[i].write_len, diag_hsic[i].num_hsic_buf_tbl_entries, diag_bridge[i].usb_connected, work_pending(&(diag_bridge[i].diag_read_work)), work_pending(&(diag_hsic[i].diag_read_hsic_work)), work_pending(&(diag_bridge[i].usb_read_complete_work))); if (bytes_written > bytes_hsic_inited) bytes_hsic_inited = bytes_written; } else { /* Check if there is room to add another HSIC entry */ if (bytes_remaining < bytes_hsic_not_inited) break; bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining, "HSIC Instance: %d has not been initialized\n\n", i); if (bytes_written > bytes_hsic_not_inited) bytes_hsic_not_inited = bytes_written; } bytes_in_buffer += bytes_written; bytes_remaining = buf_size - bytes_in_buffer; } *ppos = 0; ret = simple_read_from_buffer(ubuf, count, ppos, buf, bytes_in_buffer); diag_dbgfs_finished = 1; kfree(buf); return ret; }
static int wil_bf_debugfs_show(struct seq_file *s, void *data) { int rc; int i; struct wil6210_priv *wil = s->private; struct wmi_notify_req_cmd cmd = { .interval_usec = 0, }; struct { struct wil6210_mbox_hdr_wmi wmi; struct wmi_notify_req_done_event evt; } __packed reply; for (i = 0; i < ARRAY_SIZE(wil->sta); i++) { u32 status; cmd.cid = i; rc = wmi_call(wil, WMI_NOTIFY_REQ_CMDID, &cmd, sizeof(cmd), WMI_NOTIFY_REQ_DONE_EVENTID, &reply, sizeof(reply), 20); /* if reply is all-0, ignore this CID */ if (rc || is_all_zeros(&reply.evt, sizeof(reply.evt))) continue; status = le32_to_cpu(reply.evt.status); seq_printf(s, "CID %d {\n" " TSF = 0x%016llx\n" " TxMCS = %2d TxTpt = %4d\n" " SQI = %4d\n" " Status = 0x%08x %s\n" " Sectors(rx:tx) my %2d:%2d peer %2d:%2d\n" " Goodput(rx:tx) %4d:%4d\n" "}\n", i, le64_to_cpu(reply.evt.tsf), le16_to_cpu(reply.evt.bf_mcs), le32_to_cpu(reply.evt.tx_tpt), reply.evt.sqi, status, wil_bfstatus_str(status), le16_to_cpu(reply.evt.my_rx_sector), le16_to_cpu(reply.evt.my_tx_sector), le16_to_cpu(reply.evt.other_rx_sector), le16_to_cpu(reply.evt.other_tx_sector), le32_to_cpu(reply.evt.rx_goodput), le32_to_cpu(reply.evt.tx_goodput)); } return 0; } static int wil_bf_seq_open(struct inode *inode, struct file *file) { return single_open(file, wil_bf_debugfs_show, inode->i_private); } static const struct file_operations fops_bf = { .open = wil_bf_seq_open, .release = single_release, .read = seq_read, .llseek = seq_lseek, }; /*---------SSID------------*/ static ssize_t wil_read_file_ssid(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct wil6210_priv *wil = file->private_data; struct wireless_dev *wdev = wil_to_wdev(wil); return simple_read_from_buffer(user_buf, count, ppos, wdev->ssid, wdev->ssid_len); } static ssize_t wil_write_file_ssid(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { struct wil6210_priv *wil = file->private_data; struct wireless_dev *wdev = wil_to_wdev(wil); struct net_device *ndev = wil_to_ndev(wil); if (*ppos != 0) { wil_err(wil, "Unable to set SSID substring from [%d]\n", (int)*ppos); return -EINVAL; } if (count > sizeof(wdev->ssid)) { wil_err(wil, "SSID too long, len = %d\n", (int)count); return -EINVAL; } if (netif_running(ndev)) { wil_err(wil, "Unable to change SSID on running interface\n"); return -EINVAL; } wdev->ssid_len = count; return simple_write_to_buffer(wdev->ssid, wdev->ssid_len, ppos, buf, count); } static const struct file_operations fops_ssid = { .read = wil_read_file_ssid, .write = wil_write_file_ssid, .open = simple_open, }; /*---------temp------------*/ static void print_temp(struct seq_file *s, const char *prefix, u32 t) { switch (t) { case 0: case ~(u32)0: seq_printf(s, "%s N/A\n", prefix); break; default: seq_printf(s, "%s %d.%03d\n", prefix, t / 1000, t % 1000); break; } } static int wil_temp_debugfs_show(struct seq_file *s, void *data) { struct wil6210_priv *wil = s->private; u32 t_m, t_r; int rc = wmi_get_temperature(wil, &t_m, &t_r); if (rc) { seq_puts(s, "Failed\n"); return 0; } print_temp(s, "T_mac =", t_m); print_temp(s, "T_radio =", t_r); return 0; } static int wil_temp_seq_open(struct inode *inode, struct file *file) { return single_open(file, wil_temp_debugfs_show, inode->i_private); } static const struct file_operations fops_temp = { .open = wil_temp_seq_open, .release = single_release, .read = seq_read, .llseek = seq_lseek, }; /*---------freq------------*/ static int wil_freq_debugfs_show(struct seq_file *s, void *data) { struct wil6210_priv *wil = s->private; struct wireless_dev *wdev = wil_to_wdev(wil); u16 freq = wdev->chandef.chan ? wdev->chandef.chan->center_freq : 0; seq_printf(s, "Freq = %d\n", freq); return 0; } static int wil_freq_seq_open(struct inode *inode, struct file *file) { return single_open(file, wil_freq_debugfs_show, inode->i_private); } static const struct file_operations fops_freq = { .open = wil_freq_seq_open, .release = single_release, .read = seq_read, .llseek = seq_lseek, }; /*---------link------------*/ static int wil_link_debugfs_show(struct seq_file *s, void *data) { struct wil6210_priv *wil = s->private; struct station_info sinfo; int i, rc; for (i = 0; i < ARRAY_SIZE(wil->sta); i++) { struct wil_sta_info *p = &wil->sta[i]; char *status = "unknown"; switch (p->status) { case wil_sta_unused: status = "unused "; break; case wil_sta_conn_pending: status = "pending "; break; case wil_sta_connected: status = "connected"; break; } seq_printf(s, "[%d] %pM %s\n", i, p->addr, status); if (p->status == wil_sta_connected) { rc = wil_cid_fill_sinfo(wil, i, &sinfo); if (rc) return rc; seq_printf(s, " Tx_mcs = %d\n", sinfo.txrate.mcs); seq_printf(s, " Rx_mcs = %d\n", sinfo.rxrate.mcs); seq_printf(s, " SQ = %d\n", sinfo.signal); } } return 0; } static int wil_link_seq_open(struct inode *inode, struct file *file) { return single_open(file, wil_link_debugfs_show, inode->i_private); } static const struct file_operations fops_link = { .open = wil_link_seq_open, .release = single_release, .read = seq_read, .llseek = seq_lseek, }; /*---------info------------*/ static int wil_info_debugfs_show(struct seq_file *s, void *data) { struct wil6210_priv *wil = s->private; struct net_device *ndev = wil_to_ndev(wil); int is_ac = power_supply_is_system_supplied(); int rx = atomic_xchg(&wil->isr_count_rx, 0); int tx = atomic_xchg(&wil->isr_count_tx, 0); static ulong rxf_old, txf_old; ulong rxf = ndev->stats.rx_packets; ulong txf = ndev->stats.tx_packets; unsigned int i; /* >0 : AC; 0 : battery; <0 : error */ seq_printf(s, "AC powered : %d\n", is_ac); seq_printf(s, "Rx irqs:packets : %8d : %8ld\n", rx, rxf - rxf_old); seq_printf(s, "Tx irqs:packets : %8d : %8ld\n", tx, txf - txf_old); rxf_old = rxf; txf_old = txf; #define CHECK_QSTATE(x) (state & BIT(__QUEUE_STATE_ ## x)) ? \ " " __stringify(x) : "" for (i = 0; i < ndev->num_tx_queues; i++) { struct netdev_queue *txq = netdev_get_tx_queue(ndev, i); unsigned long state = txq->state; seq_printf(s, "Tx queue[%i] state : 0x%lx%s%s%s\n", i, state, CHECK_QSTATE(DRV_XOFF), CHECK_QSTATE(STACK_XOFF), CHECK_QSTATE(FROZEN) ); } #undef CHECK_QSTATE return 0; } static int wil_info_seq_open(struct inode *inode, struct file *file) { return single_open(file, wil_info_debugfs_show, inode->i_private); } static const struct file_operations fops_info = { .open = wil_info_seq_open, .release = single_release, .read = seq_read, .llseek = seq_lseek, }; /*---------recovery------------*/ /* mode = [manual|auto] * state = [idle|pending|running] */ static ssize_t wil_read_file_recovery(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct wil6210_priv *wil = file->private_data; char buf[80]; int n; static const char * const sstate[] = {"idle", "pending", "running"}; n = snprintf(buf, sizeof(buf), "mode = %s\nstate = %s\n", no_fw_recovery ? "manual" : "auto", sstate[wil->recovery_state]); n = min_t(int, n, sizeof(buf)); return simple_read_from_buffer(user_buf, count, ppos, buf, n); } static ssize_t wil_write_file_recovery(struct file *file, const char __user *buf_, size_t count, loff_t *ppos) { struct wil6210_priv *wil = file->private_data; static const char run_command[] = "run"; char buf[sizeof(run_command) + 1]; /* to detect "runx" */ ssize_t rc; if (wil->recovery_state != fw_recovery_pending) { wil_err(wil, "No recovery pending\n"); return -EINVAL; } if (*ppos != 0) { wil_err(wil, "Offset [%d]\n", (int)*ppos); return -EINVAL; } if (count > sizeof(buf)) { wil_err(wil, "Input too long, len = %d\n", (int)count); return -EINVAL; } rc = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, buf_, count); if (rc < 0) return rc; buf[rc] = '\0'; if (0 == strcmp(buf, run_command)) wil_set_recovery_state(wil, fw_recovery_running); else wil_err(wil, "Bad recovery command \"%s\"\n", buf); return rc; } static const struct file_operations fops_recovery = { .read = wil_read_file_recovery, .write = wil_write_file_recovery, .open = simple_open, }; /*---------Station matrix------------*/ static void wil_print_rxtid(struct seq_file *s, struct wil_tid_ampdu_rx *r) { int i; u16 index = ((r->head_seq_num - r->ssn) & 0xfff) % r->buf_size; seq_printf(s, "([%2d] %3d TU) 0x%03x [", r->buf_size, r->timeout, r->head_seq_num); for (i = 0; i < r->buf_size; i++) { if (i == index) seq_printf(s, "%c", r->reorder_buf[i] ? 'O' : '|'); else seq_printf(s, "%c", r->reorder_buf[i] ? '*' : '_'); } seq_printf(s, "] last drop 0x%03x\n", r->ssn_last_drop); }
static ssize_t iwl_dbgfs_mac_params_read(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct ieee80211_vif *vif = file->private_data; struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); struct iwl_mvm *mvm = mvmvif->mvm; u8 ap_sta_id; struct ieee80211_chanctx_conf *chanctx_conf; char buf[512]; int bufsz = sizeof(buf); int pos = 0; int i; mutex_lock(&mvm->mutex); ap_sta_id = mvmvif->ap_sta_id; switch (ieee80211_vif_type_p2p(vif)) { case NL80211_IFTYPE_ADHOC: pos += scnprintf(buf+pos, bufsz-pos, "type: ibss\n"); break; case NL80211_IFTYPE_STATION: pos += scnprintf(buf+pos, bufsz-pos, "type: bss\n"); break; case NL80211_IFTYPE_AP: pos += scnprintf(buf+pos, bufsz-pos, "type: ap\n"); break; case NL80211_IFTYPE_P2P_CLIENT: pos += scnprintf(buf+pos, bufsz-pos, "type: p2p client\n"); break; case NL80211_IFTYPE_P2P_GO: pos += scnprintf(buf+pos, bufsz-pos, "type: p2p go\n"); break; case NL80211_IFTYPE_P2P_DEVICE: pos += scnprintf(buf+pos, bufsz-pos, "type: p2p dev\n"); break; default: break; } pos += scnprintf(buf+pos, bufsz-pos, "mac id/color: %d / %d\n", mvmvif->id, mvmvif->color); pos += scnprintf(buf+pos, bufsz-pos, "bssid: %pM\n", vif->bss_conf.bssid); pos += scnprintf(buf+pos, bufsz-pos, "QoS:\n"); for (i = 0; i < ARRAY_SIZE(mvmvif->queue_params); i++) pos += scnprintf(buf+pos, bufsz-pos, "\t%d: txop:%d - cw_min:%d - cw_max = %d - aifs = %d upasd = %d\n", i, mvmvif->queue_params[i].txop, mvmvif->queue_params[i].cw_min, mvmvif->queue_params[i].cw_max, mvmvif->queue_params[i].aifs, mvmvif->queue_params[i].uapsd); if (vif->type == NL80211_IFTYPE_STATION && ap_sta_id != IWL_MVM_STATION_COUNT) { struct ieee80211_sta *sta; sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[ap_sta_id], lockdep_is_held(&mvm->mutex)); if (!IS_ERR_OR_NULL(sta)) { struct iwl_mvm_sta *mvm_sta = (void *)sta->drv_priv; pos += scnprintf(buf+pos, bufsz-pos, "ap_sta_id %d - reduced Tx power %d force %d\n", ap_sta_id, mvm_sta->bt_reduced_txpower, mvm_sta->bt_reduced_txpower_dbg); } } rcu_read_lock(); chanctx_conf = rcu_dereference(vif->chanctx_conf); if (chanctx_conf) pos += scnprintf(buf+pos, bufsz-pos, "idle rx chains %d, active rx chains: %d\n", chanctx_conf->rx_chains_static, chanctx_conf->rx_chains_dynamic); rcu_read_unlock(); mutex_unlock(&mvm->mutex); return simple_read_from_buffer(user_buf, count, ppos, buf, pos); }
static ssize_t read_file_recv(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { #define PHY_ERR(s, p) \ len += snprintf(buf + len, size - len, "%20s : %10u\n", s, \ priv->debug.rx_stats.err_phy_stats[p]); struct ath9k_htc_priv *priv = file->private_data; char *buf; unsigned int len = 0, size = 1500; ssize_t retval = 0; buf = kzalloc(size, GFP_KERNEL); if (buf == NULL) return -ENOMEM; len += snprintf(buf + len, size - len, "%20s : %10u\n", "SKBs allocated", priv->debug.rx_stats.skb_allocated); len += snprintf(buf + len, size - len, "%20s : %10u\n", "SKBs completed", priv->debug.rx_stats.skb_completed); len += snprintf(buf + len, size - len, "%20s : %10u\n", "SKBs Dropped", priv->debug.rx_stats.skb_dropped); len += snprintf(buf + len, size - len, "%20s : %10u\n", "CRC ERR", priv->debug.rx_stats.err_crc); len += snprintf(buf + len, size - len, "%20s : %10u\n", "DECRYPT CRC ERR", priv->debug.rx_stats.err_decrypt_crc); len += snprintf(buf + len, size - len, "%20s : %10u\n", "MIC ERR", priv->debug.rx_stats.err_mic); len += snprintf(buf + len, size - len, "%20s : %10u\n", "PRE-DELIM CRC ERR", priv->debug.rx_stats.err_pre_delim); len += snprintf(buf + len, size - len, "%20s : %10u\n", "POST-DELIM CRC ERR", priv->debug.rx_stats.err_post_delim); len += snprintf(buf + len, size - len, "%20s : %10u\n", "DECRYPT BUSY ERR", priv->debug.rx_stats.err_decrypt_busy); len += snprintf(buf + len, size - len, "%20s : %10u\n", "TOTAL PHY ERR", priv->debug.rx_stats.err_phy); PHY_ERR("UNDERRUN", ATH9K_PHYERR_UNDERRUN); PHY_ERR("TIMING", ATH9K_PHYERR_TIMING); PHY_ERR("PARITY", ATH9K_PHYERR_PARITY); PHY_ERR("RATE", ATH9K_PHYERR_RATE); PHY_ERR("LENGTH", ATH9K_PHYERR_LENGTH); PHY_ERR("RADAR", ATH9K_PHYERR_RADAR); PHY_ERR("SERVICE", ATH9K_PHYERR_SERVICE); PHY_ERR("TOR", ATH9K_PHYERR_TOR); PHY_ERR("OFDM-TIMING", ATH9K_PHYERR_OFDM_TIMING); PHY_ERR("OFDM-SIGNAL-PARITY", ATH9K_PHYERR_OFDM_SIGNAL_PARITY); PHY_ERR("OFDM-RATE", ATH9K_PHYERR_OFDM_RATE_ILLEGAL); PHY_ERR("OFDM-LENGTH", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL); PHY_ERR("OFDM-POWER-DROP", ATH9K_PHYERR_OFDM_POWER_DROP); PHY_ERR("OFDM-SERVICE", ATH9K_PHYERR_OFDM_SERVICE); PHY_ERR("OFDM-RESTART", ATH9K_PHYERR_OFDM_RESTART); PHY_ERR("FALSE-RADAR-EXT", ATH9K_PHYERR_FALSE_RADAR_EXT); PHY_ERR("CCK-TIMING", ATH9K_PHYERR_CCK_TIMING); PHY_ERR("CCK-HEADER-CRC", ATH9K_PHYERR_CCK_HEADER_CRC); PHY_ERR("CCK-RATE", ATH9K_PHYERR_CCK_RATE_ILLEGAL); PHY_ERR("CCK-SERVICE", ATH9K_PHYERR_CCK_SERVICE); PHY_ERR("CCK-RESTART", ATH9K_PHYERR_CCK_RESTART); PHY_ERR("CCK-LENGTH", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL); PHY_ERR("CCK-POWER-DROP", ATH9K_PHYERR_CCK_POWER_DROP); PHY_ERR("HT-CRC", ATH9K_PHYERR_HT_CRC_ERROR); PHY_ERR("HT-LENGTH", ATH9K_PHYERR_HT_LENGTH_ILLEGAL); PHY_ERR("HT-RATE", ATH9K_PHYERR_HT_RATE_ILLEGAL); if (len > size) len = size; retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); kfree(buf); return retval; #undef PHY_ERR }
/* * Proc info file read handler. * * This function is called when the 'info' file is opened for reading. * It prints the following driver related information - * - Driver name * - Driver version * - Driver extended version * - Interface name * - BSS mode * - Media state (connected or disconnected) * - MAC address * - Total number of Tx bytes * - Total number of Rx bytes * - Total number of Tx packets * - Total number of Rx packets * - Total number of dropped Tx packets * - Total number of dropped Rx packets * - Total number of corrupted Tx packets * - Total number of corrupted Rx packets * - Carrier status (on or off) * - Tx queue status (started or stopped) * * For STA mode drivers, it also prints the following extra - * - ESSID * - BSSID * - Channel * - Region code * - Multicast count * - Multicast addresses */ static ssize_t mwifiex_info_read(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { struct mwifiex_private *priv = (struct mwifiex_private *) file->private_data; struct net_device *netdev = priv->netdev; struct netdev_hw_addr *ha; unsigned long page = get_zeroed_page(GFP_KERNEL); char *p = (char *) page, fmt[64]; struct mwifiex_bss_info info; ssize_t ret; int i = 0; if (!p) return -ENOMEM; memset(&info, 0, sizeof(info)); ret = mwifiex_get_bss_info(priv, &info); if (ret) goto free_and_exit; mwifiex_drv_get_driver_version(priv->adapter, fmt, sizeof(fmt) - 1); if (!priv->version_str[0]) mwifiex_get_ver_ext(priv); p += sprintf(p, "driver_name = " "\"mwifiex\"\n"); p += sprintf(p, "driver_version = %s", fmt); p += sprintf(p, "\nverext = %s", priv->version_str); p += sprintf(p, "\ninterface_name=\"%s\"\n", netdev->name); p += sprintf(p, "bss_mode=\"%s\"\n", bss_modes[info.bss_mode]); p += sprintf(p, "media_state=\"%s\"\n", (!priv->media_connected ? "Disconnected" : "Connected")); p += sprintf(p, "mac_address=\"%pM\"\n", netdev->dev_addr); if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) { p += sprintf(p, "multicast_count=\"%d\"\n", netdev_mc_count(netdev)); p += sprintf(p, "essid=\"%s\"\n", info.ssid.ssid); p += sprintf(p, "bssid=\"%pM\"\n", info.bssid); p += sprintf(p, "channel=\"%d\"\n", (int) info.bss_chan); p += sprintf(p, "country_code = \"%s\"\n", info.country_code); netdev_for_each_mc_addr(ha, netdev) p += sprintf(p, "multicast_address[%d]=\"%pM\"\n", i++, ha->addr); } p += sprintf(p, "num_tx_bytes = %lu\n", priv->stats.tx_bytes); p += sprintf(p, "num_rx_bytes = %lu\n", priv->stats.rx_bytes); p += sprintf(p, "num_tx_pkts = %lu\n", priv->stats.tx_packets); p += sprintf(p, "num_rx_pkts = %lu\n", priv->stats.rx_packets); p += sprintf(p, "num_tx_pkts_dropped = %lu\n", priv->stats.tx_dropped); p += sprintf(p, "num_rx_pkts_dropped = %lu\n", priv->stats.rx_dropped); p += sprintf(p, "num_tx_pkts_err = %lu\n", priv->stats.tx_errors); p += sprintf(p, "num_rx_pkts_err = %lu\n", priv->stats.rx_errors); p += sprintf(p, "carrier %s\n", ((netif_carrier_ok(priv->netdev)) ? "on" : "off")); p += sprintf(p, "tx queue %s\n", ((netif_queue_stopped(priv->netdev)) ? "stopped" : "started")); ret = simple_read_from_buffer(ubuf, count, ppos, (char *) page, (unsigned long) p - page); free_and_exit: free_page(page); return ret; }
static ssize_t read_4k_modal_eeprom(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { #define PR_EEP(_s, _val) \ do { \ len += snprintf(buf + len, size - len, "%20s : %10d\n", \ _s, (_val)); \ } while (0) struct ath9k_htc_priv *priv = file->private_data; struct modal_eep_4k_header *pModal = &priv->ah->eeprom.map4k.modalHeader; unsigned int len = 0, size = 2048; ssize_t retval = 0; char *buf; buf = kzalloc(size, GFP_KERNEL); if (buf == NULL) return -ENOMEM; PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]); PR_EEP("Ant. Common Control", pModal->antCtrlCommon); PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]); PR_EEP("Switch Settle", pModal->switchSettling); PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]); PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]); PR_EEP("ADC Desired size", pModal->adcDesiredSize); PR_EEP("PGA Desired size", pModal->pgaDesiredSize); PR_EEP("Chain0 xlna Gain", pModal->xlnaGainCh[0]); PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff); PR_EEP("txEndToRxOn", pModal->txEndToRxOn); PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn); PR_EEP("CCA Threshold)", pModal->thresh62); PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]); PR_EEP("xpdGain", pModal->xpdGain); PR_EEP("External PD", pModal->xpd); PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]); PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]); PR_EEP("pdGainOverlap", pModal->pdGainOverlap); PR_EEP("O/D Bias Version", pModal->version); PR_EEP("CCK OutputBias", pModal->ob_0); PR_EEP("BPSK OutputBias", pModal->ob_1); PR_EEP("QPSK OutputBias", pModal->ob_2); PR_EEP("16QAM OutputBias", pModal->ob_3); PR_EEP("64QAM OutputBias", pModal->ob_4); PR_EEP("CCK Driver1_Bias", pModal->db1_0); PR_EEP("BPSK Driver1_Bias", pModal->db1_1); PR_EEP("QPSK Driver1_Bias", pModal->db1_2); PR_EEP("16QAM Driver1_Bias", pModal->db1_3); PR_EEP("64QAM Driver1_Bias", pModal->db1_4); PR_EEP("CCK Driver2_Bias", pModal->db2_0); PR_EEP("BPSK Driver2_Bias", pModal->db2_1); PR_EEP("QPSK Driver2_Bias", pModal->db2_2); PR_EEP("16QAM Driver2_Bias", pModal->db2_3); PR_EEP("64QAM Driver2_Bias", pModal->db2_4); PR_EEP("xPA Bias Level", pModal->xpaBiasLvl); PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart); PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn); PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc); PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]); PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]); PR_EEP("HT40 Switch Settle", pModal->swSettleHt40); PR_EEP("Chain0 xatten2Db", pModal->xatten2Db[0]); PR_EEP("Chain0 xatten2Margin", pModal->xatten2Margin[0]); PR_EEP("Ant. Diversity ctl1", pModal->antdiv_ctl1); PR_EEP("Ant. Diversity ctl2", pModal->antdiv_ctl2); PR_EEP("TX Diversity", pModal->tx_diversity); if (len > size) len = size; retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); kfree(buf); return retval; #undef PR_EEP }
/* * Proc getlog file read handler. * * This function is called when the 'getlog' file is opened for reading * It prints the following log information - * - Number of multicast Tx frames * - Number of failed packets * - Number of Tx retries * - Number of multicast Tx retries * - Number of duplicate frames * - Number of RTS successes * - Number of RTS failures * - Number of ACK failures * - Number of fragmented Rx frames * - Number of multicast Rx frames * - Number of FCS errors * - Number of Tx frames * - WEP ICV error counts */ static ssize_t mwifiex_getlog_read(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { struct mwifiex_private *priv = (struct mwifiex_private *) file->private_data; unsigned long page = get_zeroed_page(GFP_KERNEL); char *p = (char *) page; ssize_t ret; struct mwifiex_ds_get_stats stats; if (!p) return -ENOMEM; memset(&stats, 0, sizeof(stats)); ret = mwifiex_get_stats_info(priv, &stats); if (ret) goto free_and_exit; p += sprintf(p, "\n" "mcasttxframe %u\n" "failed %u\n" "retry %u\n" "multiretry %u\n" "framedup %u\n" "rtssuccess %u\n" "rtsfailure %u\n" "ackfailure %u\n" "rxfrag %u\n" "mcastrxframe %u\n" "fcserror %u\n" "txframe %u\n" "wepicverrcnt-1 %u\n" "wepicverrcnt-2 %u\n" "wepicverrcnt-3 %u\n" "wepicverrcnt-4 %u\n", stats.mcast_tx_frame, stats.failed, stats.retry, stats.multi_retry, stats.frame_dup, stats.rts_success, stats.rts_failure, stats.ack_failure, stats.rx_frag, stats.mcast_rx_frame, stats.fcs_error, stats.tx_frame, stats.wep_icv_error[0], stats.wep_icv_error[1], stats.wep_icv_error[2], stats.wep_icv_error[3]); ret = simple_read_from_buffer(ubuf, count, ppos, (char *) page, (unsigned long) p - page); free_and_exit: free_page(page); return ret; }
static ssize_t read_file_tgt_tx_stats(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct ath9k_htc_priv *priv = file->private_data; struct ath9k_htc_target_tx_stats cmd_rsp; char buf[512]; unsigned int len = 0; int ret = 0; memset(&cmd_rsp, 0, sizeof(cmd_rsp)); ath9k_htc_ps_wakeup(priv); WMI_CMD(WMI_TX_STATS_CMDID); if (ret) { ath9k_htc_ps_restore(priv); return -EINVAL; } ath9k_htc_ps_restore(priv); len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n", "Xretries", be32_to_cpu(cmd_rsp.xretries)); len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n", "FifoErr", be32_to_cpu(cmd_rsp.fifoerr)); len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n", "Filtered", be32_to_cpu(cmd_rsp.filtered)); len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n", "TimerExp", be32_to_cpu(cmd_rsp.timer_exp)); len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n", "ShortRetries", be32_to_cpu(cmd_rsp.shortretries)); len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n", "LongRetries", be32_to_cpu(cmd_rsp.longretries)); len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n", "QueueNull", be32_to_cpu(cmd_rsp.qnull)); len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n", "EncapFail", be32_to_cpu(cmd_rsp.encap_fail)); len += snprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n", "NoBuf", be32_to_cpu(cmd_rsp.nobuf)); if (len > sizeof(buf)) len = sizeof(buf); return simple_read_from_buffer(user_buf, count, ppos, buf, len); }
/* * Proc debug file read handler. * * This function is called when the 'debug' file is opened for reading * It prints the following log information - * - Interrupt count * - WMM AC VO packets count * - WMM AC VI packets count * - WMM AC BE packets count * - WMM AC BK packets count * - Maximum Tx buffer size * - Tx buffer size * - Current Tx buffer size * - Power Save mode * - Power Save state * - Deep Sleep status * - Device wakeup required status * - Number of wakeup tries * - Host Sleep configured status * - Host Sleep activated status * - Number of Tx timeouts * - Number of command timeouts * - Last timed out command ID * - Last timed out command action * - Last command ID * - Last command action * - Last command index * - Last command response ID * - Last command response index * - Last event * - Last event index * - Number of host to card command failures * - Number of sleep confirm command failures * - Number of host to card data failure * - Number of deauthentication events * - Number of disassociation events * - Number of link lost events * - Number of deauthentication commands * - Number of association success commands * - Number of association failure commands * - Number of commands sent * - Number of data packets sent * - Number of command responses received * - Number of events received * - Tx BA stream table (TID, RA) * - Rx reorder table (TID, TA, Start window, Window size, Buffer) */ static ssize_t mwifiex_debug_read(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { struct mwifiex_private *priv = (struct mwifiex_private *) file->private_data; struct mwifiex_debug_data *d = &items[0]; unsigned long page = get_zeroed_page(GFP_KERNEL); char *p = (char *) page; ssize_t ret; size_t size, addr; long val; int i, j; if (!p) return -ENOMEM; ret = mwifiex_get_debug_info(priv, &info); if (ret) goto free_and_exit; for (i = 0; i < num_of_items; i++) { p += sprintf(p, "%s=", d[i].name); size = d[i].size / d[i].num; if (i < (num_of_items - 3)) addr = d[i].addr + (size_t) &info; else /* The last 3 items are struct mwifiex_adapter variables */ addr = d[i].addr + (size_t) priv->adapter; for (j = 0; j < d[i].num; j++) { switch (size) { case 1: val = *((u8 *) addr); break; case 2: val = *((u16 *) addr); break; case 4: val = *((u32 *) addr); break; case 8: val = *((long long *) addr); break; default: val = -1; break; } p += sprintf(p, "%#lx ", val); addr += size; } p += sprintf(p, "\n"); } if (info.tx_tbl_num) { p += sprintf(p, "Tx BA stream table:\n"); for (i = 0; i < info.tx_tbl_num; i++) p += sprintf(p, "tid = %d, ra = %pM\n", info.tx_tbl[i].tid, info.tx_tbl[i].ra); } if (info.rx_tbl_num) { p += sprintf(p, "Rx reorder table:\n"); for (i = 0; i < info.rx_tbl_num; i++) { p += sprintf(p, "tid = %d, ta = %pM, " "start_win = %d, " "win_size = %d, buffer: ", info.rx_tbl[i].tid, info.rx_tbl[i].ta, info.rx_tbl[i].start_win, info.rx_tbl[i].win_size); for (j = 0; j < info.rx_tbl[i].win_size; j++) p += sprintf(p, "%c ", info.rx_tbl[i].buffer[j] ? '1' : '0'); p += sprintf(p, "\n"); } } ret = simple_read_from_buffer(ubuf, count, ppos, (char *) page, (unsigned long) p - page); free_and_exit: free_page(page); return ret; }
static ssize_t read_file_dma(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; char buf[1024]; unsigned int len = 0; u32 val[ATH9K_NUM_DMA_DEBUG_REGS]; int i, qcuOffset = 0, dcuOffset = 0; u32 *qcuBase = &val[0], *dcuBase = &val[4]; ath9k_ps_wakeup(sc); REG_WRITE(ah, AR_MACMISC, ((AR_MACMISC_DMA_OBS_LINE_8 << AR_MACMISC_DMA_OBS_S) | (AR_MACMISC_MISC_OBS_BUS_1 << AR_MACMISC_MISC_OBS_BUS_MSB_S))); len += snprintf(buf + len, sizeof(buf) - len, "Raw DMA Debug values:\n"); for (i = 0; i < ATH9K_NUM_DMA_DEBUG_REGS; i++) { if (i % 4 == 0) len += snprintf(buf + len, sizeof(buf) - len, "\n"); val[i] = REG_READ(ah, AR_DMADBG_0 + (i * sizeof(u32))); len += snprintf(buf + len, sizeof(buf) - len, "%d: %08x ", i, val[i]); } len += snprintf(buf + len, sizeof(buf) - len, "\n\n"); len += snprintf(buf + len, sizeof(buf) - len, "Num QCU: chain_st fsp_ok fsp_st DCU: chain_st\n"); for (i = 0; i < ATH9K_NUM_QUEUES; i++, qcuOffset += 4, dcuOffset += 5) { if (i == 8) { qcuOffset = 0; qcuBase++; } if (i == 6) { dcuOffset = 0; dcuBase++; } len += snprintf(buf + len, sizeof(buf) - len, "%2d %2x %1x %2x %2x\n", i, (*qcuBase & (0x7 << qcuOffset)) >> qcuOffset, (*qcuBase & (0x8 << qcuOffset)) >> (qcuOffset + 3), val[2] & (0x7 << (i * 3)) >> (i * 3), (*dcuBase & (0x1f << dcuOffset)) >> dcuOffset); } len += snprintf(buf + len, sizeof(buf) - len, "\n"); len += snprintf(buf + len, sizeof(buf) - len, "qcu_stitch state: %2x qcu_fetch state: %2x\n", (val[3] & 0x003c0000) >> 18, (val[3] & 0x03c00000) >> 22); len += snprintf(buf + len, sizeof(buf) - len, "qcu_complete state: %2x dcu_complete state: %2x\n", (val[3] & 0x1c000000) >> 26, (val[6] & 0x3)); len += snprintf(buf + len, sizeof(buf) - len, "dcu_arb state: %2x dcu_fp state: %2x\n", (val[5] & 0x06000000) >> 25, (val[5] & 0x38000000) >> 27); len += snprintf(buf + len, sizeof(buf) - len, "chan_idle_dur: %3d chan_idle_dur_valid: %1d\n", (val[6] & 0x000003fc) >> 2, (val[6] & 0x00000400) >> 10); len += snprintf(buf + len, sizeof(buf) - len, "txfifo_valid_0: %1d txfifo_valid_1: %1d\n", (val[6] & 0x00000800) >> 11, (val[6] & 0x00001000) >> 12); len += snprintf(buf + len, sizeof(buf) - len, "txfifo_dcu_num_0: %2d txfifo_dcu_num_1: %2d\n", (val[6] & 0x0001e000) >> 13, (val[6] & 0x001e0000) >> 17); len += snprintf(buf + len, sizeof(buf) - len, "pcu observe: 0x%x \n", REG_READ(ah, AR_OBS_BUS_1)); len += snprintf(buf + len, sizeof(buf) - len, "AR_CR: 0x%x \n", REG_READ(ah, AR_CR)); ath9k_ps_restore(sc); return simple_read_from_buffer(user_buf, count, ppos, buf, len); }
static ssize_t desc_read(struct file *fp, char __user *buf, size_t count, loff_t *pos) { return simple_read_from_buffer(buf, count, pos, descriptions, strlen(descriptions)); }
static ssize_t tthe_get_panel_data_debugfs_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos) { struct cyttsp5_device_access_data *dad = filp->private_data; struct cyttsp5_device *ttsp; struct device *dev; u8 config; u16 actual_read_len; u16 length = 0; u8 element_size = 0; u8 *buf_offset; u8 *buf_out; int elem; int elem_offset = 0; int print_idx = 0; int rc; int rc1; int i; mutex_lock(&dad->debugfs_lock); ttsp = dad->ttsp; dev = &ttsp->dev; buf_out = dad->tthe_get_panel_data_buf; if (!buf_out) goto release_mutex; pm_runtime_get_sync(dev); rc = cyttsp5_request_exclusive(ttsp, CY_REQUEST_EXCLUSIVE_TIMEOUT); if (rc < 0) goto put_runtime; if (dad->heatmap.scan_start) { /* Start scan */ rc = cyttsp5_exec_scan_cmd_(ttsp); if (rc < 0) goto release_exclusive; } elem = dad->heatmap.num_element; rc = cyttsp5_ret_scan_data_cmd_(ttsp, elem_offset, elem, dad->heatmap.data_type, dad->ic_buf, &config, &actual_read_len, NULL); if (rc < 0) goto release_exclusive; length = get_unaligned_le16(&dad->ic_buf[0]); buf_offset = dad->ic_buf + length; element_size = config & CY_CMD_RET_PANEL_ELMNT_SZ_MASK; elem -= actual_read_len; elem_offset = actual_read_len; while (elem > 0) { rc = cyttsp5_ret_scan_data_cmd_(ttsp, elem_offset, elem, dad->heatmap.data_type, NULL, &config, &actual_read_len, buf_offset); if (rc < 0) goto release_exclusive; if (!actual_read_len) break; length += actual_read_len * element_size; buf_offset = dad->ic_buf + length; elem -= actual_read_len; elem_offset += actual_read_len; } /* Reconstruct cmd header */ put_unaligned_le16(length, &dad->ic_buf[0]); put_unaligned_le16(elem_offset, &dad->ic_buf[7]); release_exclusive: rc1 = cyttsp5_release_exclusive(ttsp); put_runtime: pm_runtime_put(dev); if (rc < 0) goto release_mutex; print_idx += scnprintf(buf_out, TTHE_TUNER_MAX_BUF, "CY_DATA:"); for (i = 0; i < length; i++) print_idx += scnprintf(buf_out + print_idx, TTHE_TUNER_MAX_BUF - print_idx, "%02X ", dad->ic_buf[i]); print_idx += scnprintf(buf_out + print_idx, TTHE_TUNER_MAX_BUF - print_idx, ":(%d bytes)\n", length); rc = simple_read_from_buffer(buf, count, ppos, buf_out, print_idx); print_idx = rc; release_mutex: mutex_unlock(&dad->debugfs_lock); return print_idx; }
static ssize_t page_map_read( struct file *file, char __user *buf, size_t nbytes, loff_t *ppos) { return simple_read_from_buffer(buf, nbytes, ppos, PDE_DATA(file_inode(file)), PAGE_SIZE); }
VIF_STATE_PRINT_LLHEX(tx_security_seq); VIF_STATE_PRINT_INT(tx_security_last_seq_lsb); } #undef VIF_STATE_PRINT_INT #undef VIF_STATE_PRINT_LONG #undef VIF_STATE_PRINT_HEX #undef VIF_STATE_PRINT_LHEX #undef VIF_STATE_PRINT_LLHEX #undef VIF_STATE_PRINT_STR #undef VIF_STATE_PRINT_NSTR #undef VIF_STATE_PRINT mutex_unlock(&wl->mutex); ret = simple_read_from_buffer(user_buf, count, ppos, buf, res); kfree(buf); return ret; } static const struct file_operations vifs_state_ops = { .read = vifs_state_read, .open = simple_open, .llseek = default_llseek, }; static ssize_t dtim_interval_read(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct wl1271 *wl = file->private_data; u8 value;
static ssize_t iwm_debugfs_sdio_read(struct file *filp, char __user *buffer, size_t count, loff_t *ppos) { struct iwm_priv *iwm = filp->private_data; struct iwm_sdio_priv *hw = iwm_to_if_sdio(iwm); char *buf; u8 cccr; int buf_len = 4096, ret; size_t len = 0; if (*ppos != 0) return 0; if (count < sizeof(buf)) return -ENOSPC; buf = kzalloc(buf_len, GFP_KERNEL); if (!buf) return -ENOMEM; sdio_claim_host(hw->func); cccr = sdio_f0_readb(hw->func, SDIO_CCCR_IOEx, &ret); if (ret) { IWM_ERR(iwm, "Could not read SDIO_CCCR_IOEx\n"); goto err; } len += snprintf(buf + len, buf_len - len, "CCCR_IOEx: 0x%x\n", cccr); cccr = sdio_f0_readb(hw->func, SDIO_CCCR_IORx, &ret); if (ret) { IWM_ERR(iwm, "Could not read SDIO_CCCR_IORx\n"); goto err; } len += snprintf(buf + len, buf_len - len, "CCCR_IORx: 0x%x\n", cccr); cccr = sdio_f0_readb(hw->func, SDIO_CCCR_IENx, &ret); if (ret) { IWM_ERR(iwm, "Could not read SDIO_CCCR_IENx\n"); goto err; } len += snprintf(buf + len, buf_len - len, "CCCR_IENx: 0x%x\n", cccr); cccr = sdio_f0_readb(hw->func, SDIO_CCCR_INTx, &ret); if (ret) { IWM_ERR(iwm, "Could not read SDIO_CCCR_INTx\n"); goto err; } len += snprintf(buf + len, buf_len - len, "CCCR_INTx: 0x%x\n", cccr); cccr = sdio_f0_readb(hw->func, SDIO_CCCR_ABORT, &ret); if (ret) { IWM_ERR(iwm, "Could not read SDIO_CCCR_ABORTx\n"); goto err; } len += snprintf(buf + len, buf_len - len, "CCCR_ABORT: 0x%x\n", cccr); cccr = sdio_f0_readb(hw->func, SDIO_CCCR_IF, &ret); if (ret) { IWM_ERR(iwm, "Could not read SDIO_CCCR_IF\n"); goto err; } len += snprintf(buf + len, buf_len - len, "CCCR_IF: 0x%x\n", cccr); cccr = sdio_f0_readb(hw->func, SDIO_CCCR_CAPS, &ret); if (ret) { IWM_ERR(iwm, "Could not read SDIO_CCCR_CAPS\n"); goto err; } len += snprintf(buf + len, buf_len - len, "CCCR_CAPS: 0x%x\n", cccr); cccr = sdio_f0_readb(hw->func, SDIO_CCCR_CIS, &ret); if (ret) { IWM_ERR(iwm, "Could not read SDIO_CCCR_CIS\n"); goto err; } len += snprintf(buf + len, buf_len - len, "CCCR_CIS: 0x%x\n", cccr); ret = simple_read_from_buffer(buffer, len, ppos, buf, buf_len); err: sdio_release_host(hw->func); kfree(buf); return ret; }