static ssize_t wdog_dbg_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { unsigned long val; int err; enum wdog_dbg v = (enum wdog_dbg)((struct seq_file *) (file->private_data))->private; switch(v) { case WDOG_DBG_CONFIG: err = kstrtoul_from_user(user_buf, count, 0, &val); if (!err) { wdt_auto_off = val != 0; (void) ux500_wdt_ops->config(1, wdt_auto_off); } else { pr_err("ux500_wdt:dbg: unknown value\n"); } break; case WDOG_DBG_LOAD: err = kstrtoul_from_user(user_buf, count, 0, &val); if (!err) { timeout = val; /* Convert seconds to ms */ ux500_wdt_ops->disable(wdog_id); ux500_wdt_ops->load(wdog_id, timeout * 1000); ux500_wdt_ops->enable(wdog_id); } else { pr_err("ux500_wdt:dbg: unknown value\n"); } break; case WDOG_DBG_KICK: (void) ux500_wdt_ops->kick(wdog_id); break; case WDOG_DBG_EN: wdt_en = true; (void) ux500_wdt_ops->enable(wdog_id); break; case WDOG_DBG_DIS: wdt_en = false; (void) ux500_wdt_ops->disable(wdog_id); break; } return count; }
static ssize_t ath10k_write_htt_stats_mask(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct ath10k *ar = file->private_data; unsigned long mask; int ret; ret = kstrtoul_from_user(user_buf, count, 0, &mask); if (ret) return ret; /* max 8 bit masks (for now) */ if (mask > 0xff) return -E2BIG; mutex_lock(&ar->conf_mutex); ar->debug.htt_stats_mask = mask; ret = ath10k_debug_htt_stats_req(ar); if (ret) goto out; ret = count; out: mutex_unlock(&ar->conf_mutex); return ret; }
static ssize_t qperf_seq_write(struct file *file, const char __user *ubuf, size_t count, loff_t *off) { struct seq_file *seq = file->private_data; struct qdio_irq *irq_ptr = seq->private; struct qdio_q *q; unsigned long val; int ret, i; if (!irq_ptr) return 0; ret = kstrtoul_from_user(ubuf, count, 10, &val); if (ret) return ret; switch (val) { case 0: irq_ptr->perf_stat_enabled = 0; memset(&irq_ptr->perf_stat, 0, sizeof(irq_ptr->perf_stat)); for_each_input_queue(irq_ptr, q, i) memset(&q->q_stats, 0, sizeof(q->q_stats)); for_each_output_queue(irq_ptr, q, i) memset(&q->q_stats, 0, sizeof(q->q_stats)); break; case 1: irq_ptr->perf_stat_enabled = 1; break; } return count; }
static ssize_t pci_perf_seq_write(struct file *file, const char __user *ubuf, size_t count, loff_t *off) { struct zpci_dev *zdev = ((struct seq_file *) file->private_data)->private; unsigned long val; int rc; if (!zdev) return 0; rc = kstrtoul_from_user(ubuf, count, 10, &val); if (rc) return rc; switch (val) { case 0: rc = zpci_fmb_disable_device(zdev); if (rc) return rc; break; case 1: rc = zpci_fmb_enable_device(zdev); if (rc) return rc; break; } return count; }
static ssize_t rx_streaming_always_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct wl1271 *wl = file->private_data; unsigned long value; int ret; ret = kstrtoul_from_user(user_buf, count, 10, &value); if (ret < 0) { wl1271_warning("illegal value in rx_streaming_write!"); return -EINVAL; } /* valid values: 0, 10-100 */ if (!(value == 0 || value == 1)) { wl1271_warning("value is not in valid!"); return -EINVAL; } mutex_lock(&wl->mutex); wl->conf.rx_streaming.always = value; ret = wl1271_ps_elp_wakeup(wl); if (ret < 0) goto out; wl1271_recalc_rx_streaming(wl); wl1271_ps_elp_sleep(wl); out: mutex_unlock(&wl->mutex); return count; }
static ssize_t beacon_interval_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct wl1271 *wl = file->private_data; unsigned long value; int ret; ret = kstrtoul_from_user(user_buf, count, 10, &value); if (ret < 0) { wl1271_warning("illegal value for beacon_interval"); return -EINVAL; } if (value < 1 || value > 255) { wl1271_warning("beacon interval value is not in valid range"); return -ERANGE; } mutex_lock(&wl->mutex); wl->conf.conn.listen_interval = value; /* for some reason there are different event types for 1 and >1 */ if (value == 1) wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_BEACON; else wl->conf.conn.wake_up_event = CONF_WAKE_UP_EVENT_N_BEACONS; /* * we don't reconfigure ACX_WAKE_UP_CONDITIONS now, so it will only * take effect on the next time we enter psm. */ mutex_unlock(&wl->mutex); return count; }
static ssize_t ath10k_write_fw_dbglog(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct ath10k *ar = file->private_data; unsigned long mask; int ret; ret = kstrtoul_from_user(user_buf, count, 0, &mask); if (ret) return ret; mutex_lock(&ar->conf_mutex); ar->debug.fw_dbglog_mask = mask; if (ar->state == ATH10K_STATE_ON) { ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask); if (ret) { ath10k_warn("dbglog cfg failed from debugfs: %d\n", ret); goto exit; } } ret = count; exit: mutex_unlock(&ar->conf_mutex); return ret; }
static ssize_t elp_timeout_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct wl1271 *wl = file->private_data; unsigned long value; int ret; ret = kstrtoul_from_user(user_buf, count, 10, &value); if (ret < 0) { wl1271_warning("illegal value in dynamic_ps"); return -EINVAL; } if (value < 1 || value > 65535) { wl1271_warning("dyanmic_ps_timeout is not in valid range"); return -ERANGE; } mutex_lock(&wl->mutex); wl->conf.conn.elp_timeout = value; mutex_unlock(&wl->mutex); return count; }
static ssize_t write_debug_level(struct file *file, const char __user *buffer, size_t count, loff_t *ppos) { unsigned long val; int err = kstrtoul_from_user(buffer, count, 0, &val); if (err) return err; ieee80211_debug_level = val; return count; }
static ssize_t forced_ps_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct wl1271 *wl = file->private_data; struct wl12xx_vif *wlvif; unsigned long value; int ret, ps_mode; ret = kstrtoul_from_user(user_buf, count, 10, &value); if (ret < 0) { wl1271_warning("illegal value in forced_ps"); return -EINVAL; } if (value != 1 && value != 0) { wl1271_warning("forced_ps should be either 0 or 1"); return -ERANGE; } mutex_lock(&wl->mutex); if (wl->conf.conn.forced_ps == value) goto out; wl->conf.conn.forced_ps = value; if (wl->state == WL1271_STATE_OFF) goto out; ret = wl1271_ps_elp_wakeup(wl); if (ret < 0) goto out; /* In case we're already in PSM, trigger it again to switch mode * immediately without waiting for re-association */ ps_mode = value ? STATION_POWER_SAVE_MODE : STATION_AUTO_PS_MODE; wl12xx_for_each_wlvif_sta(wl, wlvif) { if (test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) wl1271_ps_set_mode(wl, wlvif, ps_mode); } wl1271_ps_elp_sleep(wl); out: mutex_unlock(&wl->mutex); return count; }
static ssize_t softsynth_write(struct file *fp, const char __user *buf, size_t count, loff_t *pos) { unsigned long supplied_index = 0; int converted; converted = kstrtoul_from_user(buf, count, 0, &supplied_index); if (converted < 0) return converted; last_index = supplied_index; return count; }
static ssize_t dynamic_ps_timeout_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct wl1271 *wl = file->private_data; struct wl12xx_vif *wlvif; unsigned long value; int ret; ret = kstrtoul_from_user(user_buf, count, 10, &value); if (ret < 0) { wl1271_warning("illegal value in dynamic_ps"); return -EINVAL; } if (value < 1 || value > 65535) { wl1271_warning("dyanmic_ps_timeout is not in valid range"); return -ERANGE; } mutex_lock(&wl->mutex); wl->conf.conn.dynamic_ps_timeout = value; if (wl->state == WL1271_STATE_OFF) goto out; ret = wl1271_ps_elp_wakeup(wl); if (ret < 0) goto out; /* In case we're already in PSM, trigger it again to set new timeout * immediately without waiting for re-association */ wl12xx_for_each_wlvif_sta(wl, wlvif) { if (test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) wl1271_ps_set_mode(wl, wlvif, STATION_AUTO_PS_MODE); } wl1271_ps_elp_sleep(wl); out: mutex_unlock(&wl->mutex); return count; }
static int ikgt_systl_debug(struct ctl_table *ctl, int write, void __user *buffer, size_t *count, loff_t *ppos) { unsigned long val; int len, rc; char buf[32]; if (!*count || (*ppos && !write)) { *count = 0; return 0; } if (!write) { len = snprintf(buf, sizeof(buf), "%d\n", ikgt_agent_debug); rc = copy_to_user(buffer, buf, sizeof(buf)); if (rc != 0) return -EFAULT; } else { len = *count; rc = kstrtoul_from_user(buffer, len, 0, &val); if (rc) return rc; ikgt_agent_debug = val; switch (val) { case 1000: test_log(); break; case 1001: test_hypercall(); break; default: ikgt_debug(val); break; } } *count = len; *ppos += len; return 0; }
/** * rsi_debug_zone_write() - This function writes into hal queues as per user * requirement. * @filp: Pointer to the file structure. * @buff: Pointer to the character buffer. * @len: Length of the data to be written into buffer. * @data: Pointer to the data. * * Return: len: Number of bytes read. */ static ssize_t rsi_debug_zone_write(struct file *filp, const char __user *buff, size_t len, loff_t *data) { unsigned long dbg_zone; int ret; if (!len) return 0; ret = kstrtoul_from_user(buff, len, 16, &dbg_zone); if (ret) return ret; rsi_zone_enabled = dbg_zone; return len; }
static ssize_t sleep_auth_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct wl1271 *wl = file->private_data; unsigned long value; int ret; ret = kstrtoul_from_user(user_buf, count, 0, &value); if (ret < 0) { wl1271_warning("illegal value in sleep_auth"); return -EINVAL; } if (value < 0 || value > WL1271_PSM_MAX) { wl1271_warning("sleep_auth must be between 0 and %d", WL1271_PSM_MAX); return -ERANGE; } mutex_lock(&wl->mutex); if (wl->state == WL1271_STATE_OFF) goto out; ret = wl1271_ps_elp_wakeup(wl); if (ret < 0) goto out; ret = wl1271_acx_sleep_auth(wl, value); if (ret < 0) goto out_sleep; out_sleep: wl1271_ps_elp_sleep(wl); out: mutex_unlock(&wl->mutex); return count; }
/* * rfs_enalbe_proc_write */ static ssize_t rfs_enable_proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos) { unsigned long val; int err = kstrtoul_from_user(buffer, count, 0, &val); if (err) return err; if (rfs_enable == val) { return count; } if (val) { rfs_start(); } else { rfs_stop(); } rfs_enable = !!val; return count; }
static ssize_t radar_debug_mode_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct wl1271 *wl = file->private_data; struct wl12xx_vif *wlvif; unsigned long value; int ret; ret = kstrtoul_from_user(user_buf, count, 10, &value); if (ret < 0) { wl1271_warning("illegal value in radar_debug_mode!"); return -EINVAL; } /* valid values: 0/1 */ if (!(value == 0 || value == 1)) { wl1271_warning("value is not in valid!"); return -EINVAL; } mutex_lock(&wl->mutex); wl->radar_debug_mode = value; if (unlikely(wl->state != WLCORE_STATE_ON)) goto out; ret = wl1271_ps_elp_wakeup(wl); if (ret < 0) goto out; wl12xx_for_each_wlvif_ap(wl, wlvif) { wlcore_cmd_generic_cfg(wl, wlvif, WLCORE_CFG_FEATURE_RADAR_DEBUG, wl->radar_debug_mode, 0); }
static ssize_t split_scan_timeout_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct wl1271 *wl = file->private_data; unsigned long value; int ret; ret = kstrtoul_from_user(user_buf, count, 10, &value); if (ret < 0) { wl1271_warning("illegal value in split_scan_timeout"); return -EINVAL; } if (value == 0) wl1271_info("split scan will be disabled"); mutex_lock(&wl->mutex); wl->conf.scan.split_scan_timeout = value * 1000; mutex_unlock(&wl->mutex); return count; }
static ssize_t gpio_power_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { struct wl1271 *wl = file->private_data; unsigned long value; int ret; ret = kstrtoul_from_user(user_buf, count, 10, &value); if (ret < 0) { wl1271_warning("illegal value in gpio_power"); return -EINVAL; } mutex_lock(&wl->mutex); if (value) wl1271_power_on(wl); else wl1271_power_off(wl); mutex_unlock(&wl->mutex); return count; }