static ssize_t android_dvfs_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int err; unsigned long vf_level; if(dvfs_enable == 0) { goto out; } err = strict_strtoul(buf, 10, &vf_level); if (err || vf_level > dvfs_max_level) { PVR_DPF((PVR_DBG_ERROR, "Invalid parameter!")); return err; } mutex_lock(&dvfs_lock); SGXDvfsChange((u32)vf_level); mutex_unlock(&dvfs_lock); out: return count; }
static ssize_t store_selfballooning(struct sys_device *dev, struct sysdev_attribute *attr, const char *buf, size_t count) { bool was_enabled = kvm_selfballooning_enabled; unsigned long tmp; int err; if (!capable(CAP_SYS_ADMIN)) return -EPERM; err = strict_strtoul(buf, 10, &tmp); if (err || ((tmp != 0) && (tmp != 1))) return -EINVAL; kvm_selfballooning_enabled = !!tmp; if (!was_enabled && kvm_selfballooning_enabled) schedule_delayed_work(&selfballoon_worker, selfballoon_interval * HZ); return count; }
static ssize_t scenario_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct mdnie_info *mdnie = dev_get_drvdata(dev); unsigned int value; int ret; ret = strict_strtoul(buf, 0, (unsigned long *)&value); dev_info(dev, "%s :: value=%d\n", __func__, value); if (value > SCENARIO_MAX) value = UI_MODE; mdnie->scenario = value; set_mdnie_value(mdnie); #if defined(CONFIG_FB_MDNIE_PWM) update_brightness(mdnie); #endif return count; }
static ssize_t set_low_pass(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct i2c_client *client = to_i2c_client(dev); unsigned long param; unsigned int low_pass; strict_strtoul(buf, 10, ¶m); if (param < 10) low_pass = ITG3200_LP_5; else if (param < 20) low_pass = ITG3200_LP_10; else if (param < 42) low_pass = ITG3200_LP_20; else if (param < 98) low_pass = ITG3200_LP_42; else if (param < 188) low_pass = ITG3200_LP_98; else if (param < 256) low_pass = ITG3200_LP_188; else low_pass = ITG3200_LP_256; itg3200_set_low_pass(client, low_pass); return count; }
static ssize_t attr_threshold_set(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { ssize_t ret; unsigned long th; struct apds9702data *data = dev_get_drvdata(dev); ret = strict_strtoul(buf, 10, &th); if (!ret && th <= APDS9702_THRESH_MAX) { mutex_lock(&data->lock); data->ctl_reg = (data->ctl_reg & ~(APDS9702_THRESH_MAX << APDS9702_THRESH_BIT)) | (th << APDS9702_THRESH_BIT); dev_dbg(dev, "%s threshold is %ld\n", __func__, th); if (data->active) { int err = i2c_smbus_write_byte_data(data->client, data->ctl_reg & 0xFF, data->ctl_reg >> 8); if (err) dev_err(dev, "%s: I2C write error = %d\n", __func__, err); }
static ssize_t disp_fps_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int err; unsigned long val; err = strict_strtoul(buf, 10, &val); if (err) { printk("Invalid size\n"); return err; } if(val > 75) { printk("Invalid value, <=75 is expected!\n"); }else { bsp_disp_lcd_set_fps(sel, val); } return count; }
static ssize_t bma250_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned long data; int error; struct i2c_client *client = to_i2c_client(dev); struct bma250_data *bma250 = i2c_get_clientdata(client); error = strict_strtoul(buf, 10, &data); if (error) return error; if (data <= 0) return -EINVAL; if (data < BMA250_MIN_DELAY) data = BMA250_MIN_DELAY; atomic_set(&bma250->delay, (unsigned int) data); return count; }
void __init plat_mem_setup(void) { char **envp = (char **) KSEG1ADDR(fw_arg2); ioport_resource.start = IOPORT_RESOURCE_START; ioport_resource.end = IOPORT_RESOURCE_END; iomem_resource.start = IOMEM_RESOURCE_START; iomem_resource.end = IOMEM_RESOURCE_END; set_io_port_base((unsigned long) KSEG1); while (*envp) { char *e = (char *)KSEG1ADDR(*envp); if (!strncmp(e, "memsize=", 8)) { e += 8; if (strict_strtoul(e, 0, &physical_memsize)) pr_warn("bad memsize specified\n"); } envp++; } physical_memsize *= 1024 * 1024; add_memory_region(0x00000000, physical_memsize, BOOT_MEM_RAM); }
static ssize_t mma7660_fuzz_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned long data; int error; struct i2c_client *client = to_i2c_client(dev); struct mma7660_data *mma7660 = i2c_get_clientdata(client); error = strict_strtoul(buf, 10, &data); if (error) return error; atomic_set(&(mma7660->fuzz), (int) data); if(mma7660->input != NULL) { mma7660->input->absinfo[ABS_X].fuzz = data; mma7660->input->absinfo[ABS_Y].fuzz = data; mma7660->input->absinfo[ABS_Z].fuzz = data; } return count; }
static ssize_t initstate_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { int ret; unsigned long do_init; struct zram *zram = dev_to_zram(dev); if (zram->init_done) { pr_info("the device is initialized device\n"); return -EBUSY; } ret = strict_strtoul(buf, 10, &do_init); if (ret) return ret; if (!do_init) return -EINVAL; zram_init_device(zram); swapon("/dev/block/zram0", 0); return len; }
static ssize_t opp_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos, int prcmu_qos_class) { char buf[32]; ssize_t buf_size; long unsigned int i; /* Get userspace string and assure termination */ buf_size = min(count, (sizeof(buf)-1)); if (copy_from_user(buf, user_buf, buf_size)) return -EFAULT; buf[buf_size] = 0; if (strict_strtoul(buf, 0, &i) != 0) return buf_size; prcmu_qos_force_opp(prcmu_qos_class, i); pr_info("prcmu debug: forced OPP for %d to %d\n", prcmu_qos_class, (int)i); return buf_size; }
static ssize_t disp_lcd_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int err; unsigned long val; err = strict_strtoul(buf, 10, &val); if (err) { printk("Invalid size\n"); return err; } if((val==0)) { drv_lcd_disable(sel); }else { drv_lcd_enable(sel); } return count; }
static ssize_t attr_torch_current_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct lm3560_drv_data *data = dev_get_drvdata(dev); unsigned long torch_current; int result; result = strict_strtoul(buf, 10, &torch_current); if (result) { dev_err(&data->client->dev, "%s(): strtoul failed, result=%d\n", __func__, result); return -EINVAL; } result = lm3560_set_torch_current(data, torch_current); if (result) return result; return size; }
static ssize_t cmpc_accel_sensitivity_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct acpi_device *acpi; struct input_dev *inputdev; struct cmpc_accel *accel; unsigned long sensitivity; int r; acpi = to_acpi_device(dev); inputdev = dev_get_drvdata(&acpi->dev); accel = dev_get_drvdata(&inputdev->dev); r = strict_strtoul(buf, 0, &sensitivity); if (r) return r; accel->sensitivity = sensitivity; cmpc_accel_set_sensitivity(acpi->handle, sensitivity); return strnlen(buf, count); }
static ssize_t disp_fastboot_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int err; unsigned long val; err = strict_strtoul(buf, 10, &val); if (err) { printk("Invalid size\n"); return err; } if((val>1)) { printk("Invalid value, 0/1 is expected!\n"); }else { printk("%ld\n", val); fastboot = val; } return count; }
static ssize_t SceneCtrlStore(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int err; unsigned long tmp; err = strict_strtoul(buf, 10, &tmp); if(err) { PVR_DPF((PVR_DBG_ERROR, "Invalid parameter!")); goto out; } if(tmp == 0 || tmp == 1) { private_data.scene_ctrl_status = tmp; } else { PVR_DPF((PVR_DBG_ERROR, "The number is too large!")); } out: return count; }
static ssize_t disp_lcd_bl_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int err; unsigned long val; err = strict_strtoul(buf, 10, &val); if (err) { printk("Invalid size\n"); return err; } if((val < 0) || (val > 255)) { printk("Invalid value, 0~255 is expected!\n"); }else { bsp_disp_lcd_set_bright(sel, val, 0); } return count; }
static ssize_t mDNIeNegative_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { unsigned int value; int ret; ret = strict_strtoul(buf, 0, (unsigned long *)&value); DPRINT("%s:value=%d\n", __func__, value); if(value == 1) { mDNIe_cfg.negative = 1; } else { mDNIe_cfg.negative = 0; mDNIe_cfg.scenario = 0; } // mipi_set_tx_power_mode(0); // High Speed Power set_mDNIe_Mode(&mDNIe_cfg); // mipi_set_tx_power_mode(1); // Low Speed Power return size; }
/* Memory scrubbing interface: * * A MC driver can limit the scrubbing bandwidth based on the CPU type. * Therefore, ->set_sdram_scrub_rate should be made to return the actual * bandwidth that is accepted or 0 when scrubbing is to be disabled. * * Negative value still means that an error has occurred while setting * the scrub rate. */ static ssize_t mci_sdram_scrub_rate_store(struct device *dev, struct device_attribute *mattr, const char *data, size_t count) { struct mem_ctl_info *mci = to_mci(dev); unsigned long bandwidth = 0; int new_bw = 0; if (!mci->set_sdram_scrub_rate) return -ENODEV; if (strict_strtoul(data, 10, &bandwidth) < 0) return -EINVAL; new_bw = mci->set_sdram_scrub_rate(mci, bandwidth); if (new_bw < 0) { edac_printk(KERN_WARNING, EDAC_MC, "Error setting scrub rate to: %lu\n", bandwidth); return -EINVAL; } return count; }
static ssize_t adxl34x_write_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct adxl34x *ac = dev_get_drvdata(dev); unsigned long val; int error; /* * This allows basic ADXL register write access for debug purposes. */ mutex_lock(&ac->mutex); error = strict_strtoul(buf, 16, &val); if (error) { mutex_unlock(&ac->mutex); return error; } AC_WRITE(ac, val >> 8, val & 0xFF); mutex_unlock(&ac->mutex); return count; }
/** * bu21013_store_attr_extclk() - Enable/Disable the external clock * for the tocuh screen controller. * @dev: pointer to device structure * @attr: pointer to device attribute * @buf: parameter buffer * @count: number of parameters * * This funtion is used enabled or disable the external clock for the touch * screen controller. */ static ssize_t bu21013_store_attr_extclk(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int retval = 0; struct bu21013_ts_data *pdata = dev_get_drvdata(dev); unsigned long val; if (strict_strtoul(buf, 0, &val)) return -EINVAL; if ((val != 0) && (val != 1)) return -EINVAL; if (pdata->chip->has_ext_clk) { if (pdata->enable) retval = bu21013_ext_clk(pdata, val, true); else pdata->ext_clk_state = val; if (retval < 0) return retval; } return count; }
ssize_t SelectDevCap(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned long devCapOffset; int status = -EINVAL; SII_DEBUG_PRINT(SII_OSAL_DEBUG_TRACE, "SelectDevCap received string: ""%s""\n", buf); do { if(strict_strtoul(buf, 0, &devCapOffset)) { SII_DEBUG_PRINT(SII_OSAL_DEBUG_TRACE, "Unable to convert register offset string\n"); break; } if(devCapOffset >= 0x0F) { SII_DEBUG_PRINT(SII_OSAL_DEBUG_TRACE, "dev cap offset (0x%x) is too large to be valid\n", devCapOffset); break; } gDriverContext.devCapOffset = (uint8_t)devCapOffset; status = count; } while(false); return status; }
static ssize_t dm3730logic_cf_debug_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { char buf[10]; unsigned long val; int buf_size, ret; memset(buf, 0, sizeof(buf)); buf_size = min(count, sizeof(buf) - 1); if (copy_from_user(buf, user_buf, buf_size)) return -EFAULT; ret = strict_strtoul(buf, 0, &val); if (ret < 0) return ret; dm3730logic_cf_debug_bits = val; *ppos += count; return count; }
static ssize_t disp_vsync_event_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int err; unsigned long val; err = strict_strtoul(buf, 10, &val); if (err) { printk("Invalid size\n"); return err; } if((val>1)) { printk("Invalid value, 0/1 is expected!\n"); }else { bsp_disp_vsync_event_enable(sel, val); } return count; }
static ssize_t mag3110_dr_mode_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct i2c_client *client; int reg, ret; unsigned long val; /* This must be done when mag3110 is disabled */ if ((strict_strtoul(buf, 10, &val) < 0) || (val > 7)) return -EINVAL; client = mag3110_pdata->client; reg = mag3110_read_reg(client, MAG3110_CTRL_REG1) & ~MAG3110_DR_MODE_MASK; reg |= (val << MAG3110_DR_MODE_OFFSET); /* MAG3110_CTRL_REG1 bit 5-7: data rate mode */ ret = mag3110_write_reg(client, MAG3110_CTRL_REG1, reg); if (ret < 0) return ret; return count; }
static ssize_t disp_colorbar_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int err; unsigned long val; err = strict_strtoul(buf, 10, &val); if (err) { printk("Invalid size\n"); return err; } if((val>7)) { printk("Invalid value, 0~7 is expected!\n"); } else { fb_draw_colorbar((__u32)g_fbi.fbinfo[val]->screen_base, g_fbi.fbinfo[val]->var.xres, g_fbi.fbinfo[val]->var.yres, &(g_fbi.fbinfo[val]->var));; } return count; }
static ssize_t attr_privacy_current_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct lm356x_drv_data *data = dev_get_drvdata(dev); unsigned long privacy_current; int result; if (1 <= data->privacy_led_nums) { result = strict_strtoul(buf, 10, &privacy_current); if (result) return -EINVAL; result = lm356x_set_privacy_current(data, privacy_current); if (result) return result; } else return -EINVAL; return size; }
static ssize_t disp_print_cmd_level_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int err; unsigned long val; err = strict_strtoul(buf, 10, &val); if (err) { printk("Invalid size\n"); return err; } if((val != 0) && (val != 1)) { printk("Invalid value, 0/1 is expected!\n"); }else { disp_print_cmd_level = val; } return count; }
static int afe_get_parameters(char *buf, long int *param1, int num_of_par) { char *token; int base, cnt; token = strsep(&buf, " "); for (cnt = 0; cnt < num_of_par; cnt++) { if (token != NULL) { if ((token[1] == 'x') || (token[1] == 'X')) base = 16; else base = 10; if (strict_strtoul(token, base, ¶m1[cnt]) != 0) return -EINVAL; token = strsep(&buf, " "); } else return -EINVAL; } return 0; }
static ssize_t attr_flash_duration_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct lm3561_drv_data *data = dev_get_drvdata(dev); unsigned long flash_duration; int result; result = strict_strtoul(buf, 10, &flash_duration); if (result) { dev_err(&data->client->dev, "%s(): strtoul failed, result=%d\n", __func__, result); return -EINVAL; } result = lm3561_set_flash_duration(data, flash_duration); if (result) return result; return size; }