コード例 #1
0
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;
}
コード例 #2
0
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;
}
コード例 #3
0
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;
}
コード例 #4
0
ファイル: itg3200.c プロジェクト: virt2real/IMU
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, &param);
	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;
}
コード例 #5
0
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);
		}
コード例 #6
0
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;
}
コード例 #7
0
ファイル: bma250_driver.c プロジェクト: Philippe12/kernel_msm
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;
}
コード例 #8
0
ファイル: setup.c プロジェクト: janfj/dd-wrt
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);
}
コード例 #9
0
ファイル: mma7660.c プロジェクト: advx9600/kernel-4.4-RuiEr
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;
}
コード例 #10
0
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;
}
コード例 #11
0
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;
}
コード例 #12
0
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;
}
コード例 #13
0
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;
}
コード例 #14
0
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);
}
コード例 #15
0
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;
}
コード例 #16
0
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;
}
コード例 #17
0
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;
}
コード例 #18
0
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;
}
コード例 #19
0
/* 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;
}
コード例 #20
0
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;
}
コード例 #21
0
/**
 * 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;
}
コード例 #22
0
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;
}
コード例 #23
0
ファイル: dm3730logic-cf.c プロジェクト: Aircell/asp-kernel
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;
}
コード例 #24
0
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;
}
コード例 #25
0
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;
}
コード例 #26
0
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;
}
コード例 #27
0
ファイル: lm356x.c プロジェクト: 325116067/semc-qsd8x50
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;
}
コード例 #28
0
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;
}
コード例 #29
0
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, &param1[cnt]) != 0)
				return -EINVAL;

			token = strsep(&buf, " ");
		} else
			return -EINVAL;
	}
	return 0;
}
コード例 #30
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;
}