自学教程：C++ strict_strtoul函数代码示例

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 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;}

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 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 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;}

/* 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, &param1[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;}