static void __init zfcp_init_device_setup(char *devstr)
{
char *token;
char *str, *str_saved;
char busid[ZFCP_BUS_ID_SIZE];
u64 wwpn, lun;
/* duplicate devstr and keep the original for sysfs presentation*/
str_saved = kstrdup(devstr, GFP_KERNEL);
str = str_saved;
if (!str)
return;
token = strsep(&str, ",");
if (!token || strlen(token) >= ZFCP_BUS_ID_SIZE)
goto err_out;
strncpy(busid, token, ZFCP_BUS_ID_SIZE);
token = strsep(&str, ",");
if (!token || kstrtoull(token, 0, (unsigned long long *) &wwpn))
goto err_out;
token = strsep(&str, ",");
if (!token || kstrtoull(token, 0, (unsigned long long *) &lun))
goto err_out;
kfree(str_saved);
zfcp_init_device_configure(busid, wwpn, lun);
return;
err_out:
kfree(str_saved);
pr_err("%s is not a valid SCSI device\n", devstr);
}
static ssize_t disksize_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t len)
{
int ret;
u64 disksize;
struct zram *zram = dev_to_zram(dev);
ret = kstrtoull(buf, 10, &disksize);
if (ret)
return ret;
down_write(&zram->init_lock);
if (zram->init_done) {
up_write(&zram->init_lock);
pr_info("Cannot change disksize for initialized device\n");
return -EBUSY;
}
zram->disksize = PAGE_ALIGN(disksize);
set_capacity(zram->disk, zram->disksize >> SECTOR_SHIFT);
up_write(&zram->init_lock);
if (zram_init_device(zram) != 0) {
printk(KERN_ALERT"\n\nzram_init_device failed!\n\n");
}
return len;
}
static ssize_t tool_peer_mw_trans_write(struct file *filep,
const char __user *ubuf,
size_t size, loff_t *offp)
{
struct tool_mw *mw = filep->private_data;
char buf[32];
size_t buf_size;
unsigned long long val;
int rc;
buf_size = min(size, (sizeof(buf) - 1));
if (copy_from_user(buf, ubuf, buf_size))
return -EFAULT;
buf[buf_size] = '\0';
rc = kstrtoull(buf, 0, &val);
if (rc)
return rc;
tool_free_mw(mw->tc, mw->idx);
if (val)
rc = tool_setup_mw(mw->tc, mw->idx, val);
if (rc)
return rc;
return size;
}
static int __init dhd_mac_addr_setup(char *str)
{
char macstr[IFHWADDRLEN*3];
char *macptr = macstr;
char *token;
int i = 0;
if (!str)
return 0;
BCM_DBG("wlan MAC = %s\n", str);
if (strlen(str) >= sizeof(macstr))
return 0;
strlcpy(macstr, str, sizeof(macstr));
while (((token = strsep(&macptr, ":")) != NULL) && (i < IFHWADDRLEN)) {
unsigned long val;
int res;
res = kstrtoul(token, 0x10, &val);
if (res < 0)
break;
brcm_mac_addr[i++] = (u8)val;
}
if (i < IFHWADDRLEN && strlen(macstr)==IFHWADDRLEN*2) {
/* try again with wrong format (sans colons) */
u64 mac;
if (kstrtoull(macstr, 0x10, &mac) < 0)
return 0;
for (i=0; i<IFHWADDRLEN; i++)
brcm_mac_addr[IFHWADDRLEN-1-i] = (u8)((0xFF)&(mac>>(i*8)));
}
static ssize_t ieee80211_if_parse_tsf(
struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
{
struct ieee80211_local *local = sdata->local;
unsigned long long tsf;
int ret;
if (strncmp(buf, "reset", 5) == 0) {
if (local->ops->reset_tsf) {
drv_reset_tsf(local, sdata);
wiphy_info(local->hw.wiphy, "debugfs reset TSF\n");
}
} else {
ret = kstrtoull(buf, 10, &tsf);
if (ret < 0)
return -EINVAL;
if (local->ops->set_tsf) {
drv_set_tsf(local, sdata, tsf);
wiphy_info(local->hw.wiphy,
"debugfs set TSF to %#018llx\n", tsf);
}
}
return buflen;
}
static ssize_t ds1682_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
struct i2c_client *client = to_i2c_client(dev);
u64 val;
__le32 val_le;
int rc;
dev_dbg(dev, "ds1682_store() called on %s\n", attr->attr.name);
/* Decode input */
rc = kstrtoull(buf, 0, &val);
if (rc < 0) {
dev_dbg(dev, "input string not a number\n");
return -EINVAL;
}
/* Special case: the 32 bit regs are time values with 1/4s
* resolution, scale input down to quarter-seconds */
if (sattr->nr == 4)
do_div(val, 250);
/* write out the value */
val_le = cpu_to_le32(val);
rc = i2c_smbus_write_i2c_block_data(client, sattr->index, sattr->nr,
(u8 *) & val_le);
if (rc < 0) {
dev_err(dev, "register write failed; reg=0x%x, size=%i\n",
sattr->index, sattr->nr);
return -EIO;
}
return count;
}
static void dummy_proc_write(struct snd_info_entry *entry,
struct snd_info_buffer *buffer)
{
struct snd_dummy *dummy = entry->private_data;
char line[64];
while (!snd_info_get_line(buffer, line, sizeof(line))) {
char item[20];
const char *ptr;
unsigned long long val;
int i;
ptr = snd_info_get_str(item, line, sizeof(item));
for (i = 0; i < ARRAY_SIZE(fields); i++) {
if (!strcmp(item, fields[i].name))
break;
}
if (i >= ARRAY_SIZE(fields))
continue;
snd_info_get_str(item, ptr, sizeof(item));
if (kstrtoull(item, 0, &val))
continue;
if (fields[i].size == sizeof(int))
*get_dummy_int_ptr(dummy, fields[i].offset) = val;
else
*get_dummy_ll_ptr(dummy, fields[i].offset) = val;
}
}
static int nilfs_parse_snapshot_option(const char *option,
const substring_t *arg,
struct nilfs_super_data *sd)
{
unsigned long long val;
const char *msg = NULL;
int err;
if (!(sd->flags & MS_RDONLY)) {
msg = "read-only option is not specified";
goto parse_error;
}
err = kstrtoull(arg->from, 0, &val);
if (err) {
if (err == -ERANGE)
msg = "too large checkpoint number";
else
msg = "malformed argument";
goto parse_error;
} else if (val == 0) {
msg = "invalid checkpoint number 0";
goto parse_error;
}
sd->cno = val;
return 0;
parse_error:
nilfs_msg(NULL, KERN_ERR, "invalid option \"%s\": %s", option, msg);
return 1;
}
static ssize_t
memory_probe_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
u64 phys_addr;
int nid, ret;
unsigned long pages_per_block = PAGES_PER_SECTION * sections_per_block;
ret = kstrtoull(buf, 0, &phys_addr);
if (ret)
return ret;
if (phys_addr & ((pages_per_block << PAGE_SHIFT) - 1))
return -EINVAL;
nid = memory_add_physaddr_to_nid(phys_addr);
ret = add_memory(nid, phys_addr,
MIN_MEMORY_BLOCK_SIZE * sections_per_block);
if (ret)
goto out;
ret = count;
out:
return ret;
}
static ssize_t disksize_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t len)
{
int ret;
u64 disksize;
struct zram *zram = dev_to_zram(dev);
ret = kstrtoull(buf, 10, &disksize);
if (ret)
return ret;
down_write(&zram->init_lock);
if (zram->init_done) {
up_write(&zram->init_lock);
pr_info("Cannot change disksize for initialized device\n");
return -EBUSY;
}
#ifdef CONFIG_ZRAM_FOR_ANDROID
if (!disksize) {
disksize = default_disksize_perc_ram *
((totalram_pages << PAGE_SHIFT) / 100);
}
#endif
zram->disksize = PAGE_ALIGN(disksize);
set_capacity(zram->disk, zram->disksize >> SECTOR_SHIFT);
up_write(&zram->init_lock);
return len;
}
static ssize_t disksize_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t len)
{
int ret;
u64 disksize;
ret = kstrtoull(buf, 10, &disksize);
if (ret)
return ret;
vnswap_init_disksize(disksize);
return len;
}
int kstrtou8(const char *s, unsigned int base, u8 *res)
{
unsigned long long tmp;
int rv;
rv = kstrtoull(s, base, &tmp);
if (rv < 0)
return rv;
if (tmp != (unsigned long long)(u8)tmp)
return -ERANGE;
*res = tmp;
return 0;
}
static ssize_t resume_offset_store(struct kobject *kobj,
struct kobj_attribute *attr, const char *buf,
size_t n)
{
unsigned long long offset;
int rc;
rc = kstrtoull(buf, 0, &offset);
if (rc)
return rc;
swsusp_resume_block = offset;
return n;
}
/*---------------------------------------------------------------------------*/
int parse_cmdline(struct xio_test_config *test_config, char **argv)
{
uint32_t tmp = 0;
if (!argv[1]) {
usage(argv[0]);
pr_err("NO IP was given\n");
return -1;
}
sprintf(test_config->server_addr, "%s", argv[1]);
if (argv[2]) {
if (kstrtouint(argv[2], 0, &tmp))
pr_err("parse error\n");
test_config->server_port = (uint16_t)tmp;
}
if (argv[3])
sprintf(test_config->transport, "%s", argv[3]);
if (argv[4])
if (kstrtouint(argv[4], 0, &test_config->hdr_len))
pr_err("parse error\n");
if (argv[5])
if (kstrtouint(argv[5], 0, &test_config->data_len))
pr_err("parse error\n");
if (argv[6]) {
if (kstrtouint(argv[6], 0, &test_config->iov_len))
pr_err("parse error\n");
if (test_config->iov_len > SG_TBL_LEN) {
pr_err("iov_len (%d) > %d\n",
test_config->iov_len, SG_TBL_LEN);
return -1;
}
}
if (argv[7])
if (kstrtouint(argv[7], 0, &test_config->finite_run))
pr_err("parse error\n");
if (argv[8]) {
if (kstrtoull(argv[8], 16, &test_config->cpu_mask))
pr_err("parse error\n");
}
return 0;
}
/* Forcibly offline a page, including killing processes. */
static ssize_t
store_hard_offline_page(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int ret;
u64 pfn;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
if (kstrtoull(buf, 0, &pfn) < 0)
return -EINVAL;
pfn >>= PAGE_SHIFT;
ret = memory_failure(pfn, 0, 0);
return ret ? ret : count;
}
static int get_cache_sram_params(struct sram_parameters *sram_params)
{
unsigned long long addr;
unsigned int size;
if (!sram_size || (kstrtouint(sram_size, 0, &size) < 0))
return -EINVAL;
if (!sram_offset || (kstrtoull(sram_offset, 0, &addr) < 0))
return -EINVAL;
sram_params->sram_offset = addr;
sram_params->sram_size = size;
return 0;
}
/**
* Return pointer to the key under iterator.
*
* \param di - osd iterator
*/
static struct dt_key *osd_it_acct_key(const struct lu_env *env,
const struct dt_it *di)
{
struct osd_it_quota *it = (struct osd_it_quota *)di;
zap_attribute_t *za = &osd_oti_get(env)->oti_za;
int rc;
ENTRY;
it->oiq_reset = 0;
rc = -zap_cursor_retrieve(it->oiq_zc, za);
if (rc)
RETURN(ERR_PTR(rc));
rc = kstrtoull(za->za_name, 16, &it->oiq_id);
RETURN((struct dt_key *) &it->oiq_id);
}
/*
* cf. linux/lib/parser.c and cmdline.c
* gave up calling memparse() since it uses simple_strtoull() instead of
* kstrto...().
*/
static int noinline_for_stack
au_match_ull(substring_t *s, unsigned long long *result)
{
int err;
unsigned int len;
char a[32];
err = -ERANGE;
len = s->to - s->from;
if (len + 1 <= sizeof(a)) {
memcpy(a, s->from, len);
a[len] = '\0';
err = kstrtoull(a, 0, result);
}
return err;
}
/* Soft offline a page */
static ssize_t
store_soft_offline_page(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int ret;
u64 pfn;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
if (kstrtoull(buf, 0, &pfn) < 0)
return -EINVAL;
pfn >>= PAGE_SHIFT;
if (!pfn_valid(pfn))
return -ENXIO;
ret = soft_offline_page(pfn_to_page(pfn), 0);
return ret == 0 ? count : ret;
}
int kstrtoll(const char *s, unsigned int base, long long *res)
{
unsigned long long tmp;
int rv;
if (s[0] == '-') {
rv = _kstrtoull(s + 1, base, &tmp);
if (rv < 0)
return rv;
if ((long long)(-tmp) >= 0)
return -ERANGE;
*res = -tmp;
} else {
rv = kstrtoull(s, base, &tmp);
if (rv < 0)
return rv;
if ((long long)tmp < 0)
return -ERANGE;
*res = tmp;
}
return 0;
}
static ssize_t ieee80211_if_parse_tsf(
struct ieee80211_sub_if_data *sdata, const char *buf, int buflen)
{
struct ieee80211_local *local = sdata->local;
unsigned long long tsf;
int ret;
int tsf_is_delta = 0;
if (strncmp(buf, "reset", 5) == 0) {
if (local->ops->reset_tsf) {
drv_reset_tsf(local, sdata);
wiphy_info(local->hw.wiphy, "debugfs reset TSF\n");
}
} else {
if (buflen > 10 && buf[1] == '=') {
if (buf[0] == '+')
tsf_is_delta = 1;
else if (buf[0] == '-')
tsf_is_delta = -1;
else
return -EINVAL;
buf += 2;
}
ret = kstrtoull(buf, 10, &tsf);
if (ret < 0)
return ret;
if (tsf_is_delta)
tsf = drv_get_tsf(local, sdata) + tsf_is_delta * tsf;
if (local->ops->set_tsf) {
drv_set_tsf(local, sdata, tsf);
wiphy_info(local->hw.wiphy,
"debugfs set TSF to %#018llx\n", tsf);
}
}
ieee80211_recalc_dtim(local, sdata);
return buflen;
}
static ssize_t
qfprom_store_version(struct sys_device *dev,
struct sysdev_attribute *attr,
const char *buf, size_t count)
{
uint64_t version;
uint32_t qfprom_api_status;
int32_t ret;
struct qfprom_write_ip {
uint32_t row_reg_addr;
uint32_t row_data_addr;
uint32_t bus_clk;
uint32_t qfprom_ret_ptr;
} wrip;
/* Input validation handled here */
ret = kstrtoull(buf, 0, &version);
if (ret)
return ret;
wrip.row_reg_addr = QFPROM_RAW_SPARE_REG27_ROW0_LSB;
wrip.row_data_addr = virt_to_phys(&version);
wrip.bus_clk = (64 * 1000);
wrip.qfprom_ret_ptr = virt_to_phys(&qfprom_api_status);
ret = scm_call(SCM_SVC_FUSE, QFPROM_ROW_ROLLBACK_WRITE_CMD,
&wrip, sizeof(wrip), NULL, 0);
if (ret && qfprom_api_status) {
pr_err("%s: Error in QFPROM write (%d, 0x%x)\n",
__func__, ret, qfprom_api_status);
return ret;
}
/* Return the count argument since entire buffer is used */
return count;
}
static int human_to_bytes(char *size_str, unsigned long long *size)
{
char h;
unsigned long long coef;
int ret;
//printk(KERN_DEBUG "DEBUG: human_to_bytes: buff: %s\n", size_str);
coef = 1;
h = size_str[strlen(size_str) - 1];
/* get human format if any and set coeff */
switch (h) {
case 'G':
coef = GB;
size_str[strlen(size_str) - 1] = '\0';
break;
case 'M':
coef = MB;
size_str[strlen(size_str) - 1] = '\0';
break;
case 'k':
coef = kB;
size_str[strlen(size_str) - 1] = '\0';
break;
default:
coef = 1;
}
/* calculate size */
ret = kstrtoull(size_str, 10, size);
if (ret != 0) {
SRB_LOG_ERR(srb_log, "Invalid volume size %s (%llu) (ret: %d)", size_str, *size, ret);
return -EINVAL;
}
*size = *size * coef;
return 0;
}
1 << st->rf_div_sel, prescaler ? "8/9" : "4/5");
return adf5355_sync_config(st, false);
}
static ssize_t adf5355_write(struct iio_dev *indio_dev,
uintptr_t private,
const struct iio_chan_spec *chan,
const char *buf, size_t len)
{
struct adf5355_state *st = iio_priv(indio_dev);
unsigned long long readin;
unsigned long tmp;
int ret;
ret = kstrtoull(buf, 10, &readin);
if (ret)
return ret;
mutex_lock(&indio_dev->mlock);
switch ((u32)private) {
case ADF5355_FREQ:
ret = adf5355_set_freq(st, readin, chan->channel);
break;
case ADF5355_FREQ_REFIN:
if (readin > ADF5355_MAX_FREQ_REFIN) {
ret = -EINVAL;
break;
}
if (st->clk) {
