dev_drv->ops->cfg_done(dev_drv);
	}
	return count;
}

static ssize_t show_lcdc_id(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct fb_info *fbi = dev_get_drvdata(dev);
	struct rk_lcdc_driver *dev_drv =
	    (struct rk_lcdc_driver *)fbi->par;
	return snprintf(buf, PAGE_SIZE, "%d\n", dev_drv->id);
}

static struct device_attribute rkfb_attrs[] = {
	__ATTR(phys_addr, S_IRUGO, show_phys, NULL),
	__ATTR(virt_addr, S_IRUGO, show_virt, NULL),
	__ATTR(disp_info, S_IRUGO, show_disp_info, NULL),
	__ATTR(screen_info, S_IRUGO, show_screen_info, NULL),
	__ATTR(dual_mode, S_IRUGO, show_dual_mode, NULL),
	__ATTR(enable, S_IRUGO | S_IWUSR, show_fb_state, set_fb_state),
	__ATTR(overlay, S_IRUGO | S_IWUSR, show_overlay, set_overlay),
	__ATTR(fps, S_IRUGO | S_IWUSR, show_fps, set_fps),
	__ATTR(map, S_IRUGO | S_IWUSR, show_fb_win_map, set_fb_win_map),
	__ATTR(dsp_lut, S_IRUGO | S_IWUSR, show_dsp_lut, set_dsp_lut),
	__ATTR(cabc, S_IRUGO | S_IWUSR, show_dsp_cabc, set_dsp_cabc),
	__ATTR(bcsh, S_IRUGO | S_IWUSR, show_dsp_bcsh, set_dsp_bcsh),
	__ATTR(scale, S_IRUGO | S_IWUSR, show_scale, set_scale),
	__ATTR(lcdcid, S_IRUGO, show_lcdc_id, NULL),
};
	if(!sDev){
		return -EPERM;
	}
	memset(buf, 0, size);
	mutex_lock(&sDev->mutex);
	if(sDev->calibrate && 
		size == sizeof(Sensor_Calibrate_Infor) && 
		sDev->calibrate(Read, (void *) buf, size)){
		siz = size;
	}
	mutex_unlock(&sDev->mutex);
	return siz;
}

static struct device_attribute sensor_class_attrs[] = {
	__ATTR(enable, 0660, getSensorActive, setSensorActive),
	__ATTR(delay, 0660, getSensorDelay, setSensorDelay),
	__ATTR(dumpLevel, 0660, getSensorDumpLevel, setSensorDumpLevel),
	__ATTR(dump, 0440, getInternalDump, NULL),
	__ATTR_NULL,
};

static struct bin_attribute sensor_class_bin_attrs[] = {
	__BIN_ATTR(deviceInfor, 0440, sizeof(struct device_infor), NULL, getDeviceInfor, NULL),
	__BIN_ATTR(calibrate, 0660, sizeof(Sensor_Calibrate_Infor), NULL, getCalibrate, setCalibrate),
	__ATTR_NULL,
};

static int sensor_suspend(struct device* dev, pm_message_t state)
{
	return 0;
示例#3
0
static DEVICE_ATTR(lux, 0644, lightsensor_file_state_show,
	NULL);
#else
static DEVICE_ATTR(proximity_avg, 0644,
		   proximity_avg_show, proximity_avg_store);
static DEVICE_ATTR(proximity_state, 0644, proximity_state_show, NULL);

static DEVICE_ATTR(lightsensor_file_state, 0644, lightsensor_file_state_show,
	NULL);
#endif

static DEVICE_ATTR(poll_delay, S_IRUGO | S_IWUSR | S_IWGRP,
		   poll_delay_show, poll_delay_store);

static struct device_attribute dev_attr_light_enable =
	__ATTR(enable, S_IRUGO | S_IWUSR | S_IWGRP,
	       light_enable_show, light_enable_store);

static struct device_attribute dev_attr_proximity_enable =
	__ATTR(enable, S_IRUGO | S_IWUSR | S_IWGRP,
	       proximity_enable_show, proximity_enable_store);

static struct attribute *light_sysfs_attrs[] = {
	&dev_attr_light_enable.attr,
	&dev_attr_poll_delay.attr,
	NULL
};

static struct attribute_group light_attribute_group = {
	.attrs = light_sysfs_attrs,
};
示例#4
0
	return (s - buf);
}

static ssize_t wdt_store(struct device *dev,
		            struct device_attribute *attr, const char *buf, size_t n)
{
    long soft_en = 0;

    sscanf(buf,"%ld", &soft_en);
	soft_noboot = soft_en;

    return n;
}

static struct device_attribute wdt_attr = __ATTR(soft, S_IRUGO | S_IWUSR, wdt_show, wdt_store);

/* sys attribte group */
static struct attribute *attrs[] = { 
	    &wdt_attr.attr, NULL,
};

static struct attribute_group attr_group = { 
	        .attrs = (struct attribute **)attrs,
};
#endif

/* watchdog control routines */
#define DBG(fmt, ...)					\
do {							\
	if (debug)					\
}

static ssize_t ir_enable_store(struct device *dev,
					struct device_attribute *attr,
					const char *buf, size_t count)
{
	unsigned long val;
	int err = strict_strtoul(buf, 10, &val);
	if (err || val > 1)
		return -EINVAL;
	err = ir_remote_power(dev, val);
	return err ? err : strnlen(buf, count);
}

static struct device_attribute ir_enable_attr =
	__ATTR(enable, 0200, NULL, ir_enable_store);

static int ir_remote_probe(struct platform_device *pdev)
{
	int rc;

	dev_info(&pdev->dev, "%s: probing device\n", __func__);

	rc = ir_remote_setup(&pdev->dev, 1);
	if (rc) {
		dev_err(&pdev->dev, "device_create_file, rc %d\n", rc);
		goto err_setup;
	}

	rc = device_create_file(&pdev->dev, &ir_enable_attr);
	if (rc) {
示例#6
0
文件: pm.c 项目: 12zz/linux
static ssize_t idle_store(struct kobject *kobj, struct kobj_attribute *attr,
			  const char * buf, size_t n)
{
	unsigned short value;
	if (sscanf(buf, "%hu", &value) != 1 ||
	    (value != 0 && value != 1) ||
	    (value != 0 && !IS_ENABLED(CONFIG_OMAP_32K_TIMER))) {
		pr_err("idle_sleep_store: Invalid value\n");
		return -EINVAL;
	}
	enable_dyn_sleep = value;
	return n;
}

static struct kobj_attribute sleep_while_idle_attr =
	__ATTR(sleep_while_idle, 0644, idle_show, idle_store);


static void (*omap_sram_suspend)(unsigned long r0, unsigned long r1) = NULL;

/*
 * Let's power down on idle, but only if we are really
 * idle, because once we start down the path of
 * going idle we continue to do idle even if we get
 * a clock tick interrupt . .
 */
void omap1_pm_idle(void)
{
	extern __u32 arm_idlect1_mask;
	__u32 use_idlect1 = arm_idlect1_mask;
int new_force_fast_charge;

sscanf(buf, "%du", &new_force_fast_charge);

if (new_force_fast_charge >= FAST_CHARGE_DISABLED && new_force_fast_charge <= FAST_CHARGE_FORCE_AC_IF_NO_USB) {

	/* update only if valid value provided */
	force_fast_charge = new_force_fast_charge;

}

return count;
}

static struct kobj_attribute force_fast_charge_attribute =
__ATTR(force_fast_charge, 0666, force_fast_charge_show, force_fast_charge_store);

static struct attribute *force_fast_charge_attrs[] = {
&force_fast_charge_attribute.attr,
NULL,
};

static struct attribute_group force_fast_charge_attr_group = {
.attrs = force_fast_charge_attrs,
};

/* sysfs interface for "USB_peripheral_detected" */
static ssize_t USB_peripheral_detected_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
{
return sprintf(buf, "%d\n", USB_peripheral_detected);
}
示例#8
0
 *  We create these files under /sys/firmware/opal.
 *
 *   image		: Interface to load candidate firmware image
 *   validate_flash	: Validate firmware image
 *   manage_flash	: Commit/Reject firmware image
 *   update_flash	: Flash new firmware image
 *
 */
static struct bin_attribute image_data_attr = {
	.attr = {.name = "image", .mode = 0200},
	.size = MAX_IMAGE_SIZE,	/* Limit image size */
	.write = image_data_write,
};

static struct kobj_attribute validate_attribute =
	__ATTR(validate_flash, 0600, validate_show, validate_store);

static struct kobj_attribute manage_attribute =
	__ATTR(manage_flash, 0600, manage_show, manage_store);

static struct kobj_attribute update_attribute =
	__ATTR(update_flash, 0600, update_show, update_store);

static struct attribute *image_op_attrs[] = {
	&validate_attribute.attr,
	&manage_attribute.attr,
	&update_attribute.attr,
	NULL	/* need to NULL terminate the list of attributes */
};

static struct attribute_group image_op_attr_group = {
示例#9
0
文件: core.c 项目: 454053205/linux
			dev_name(dev), dssdev->driver_name, driver->name);

	return strcmp(dssdev->driver_name, driver->name) == 0;
}

static ssize_t device_name_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct omap_dss_device *dssdev = to_dss_device(dev);
	return snprintf(buf, PAGE_SIZE, "%s\n",
			dssdev->name ?
			dssdev->name : "");
}

static struct device_attribute default_dev_attrs[] = {
	__ATTR(name, S_IRUGO, device_name_show, NULL),
	__ATTR_NULL,
};

static ssize_t driver_name_show(struct device_driver *drv, char *buf)
{
	struct omap_dss_driver *dssdrv = to_dss_driver(drv);
	return snprintf(buf, PAGE_SIZE, "%s\n",
			dssdrv->driver.name ?
			dssdrv->driver.name : "");
}
static struct driver_attribute default_drv_attrs[] = {
	__ATTR(name, S_IRUGO, driver_name_show, NULL),
	__ATTR_NULL,
};
示例#10
0
文件: sysfs.c 项目: MrJwiz/UBER-M
SYSFS_PMCSETUP(der, SPRN_PA6T_DER);
SYSFS_PMCSETUP(mer, SPRN_PA6T_MER);
SYSFS_PMCSETUP(ber, SPRN_PA6T_BER);
SYSFS_PMCSETUP(ier, SPRN_PA6T_IER);
SYSFS_PMCSETUP(sier, SPRN_PA6T_SIER);
SYSFS_PMCSETUP(siar, SPRN_PA6T_SIAR);
SYSFS_PMCSETUP(tsr0, SPRN_PA6T_TSR0);
SYSFS_PMCSETUP(tsr1, SPRN_PA6T_TSR1);
SYSFS_PMCSETUP(tsr2, SPRN_PA6T_TSR2);
SYSFS_PMCSETUP(tsr3, SPRN_PA6T_TSR3);
#endif /* CONFIG_DEBUG_KERNEL */
#endif /* HAS_PPC_PMC_PA6T */

#ifdef HAS_PPC_PMC_IBM
static struct device_attribute ibm_common_attrs[] = {
	__ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
	__ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
};
#endif /* HAS_PPC_PMC_G4 */

#ifdef HAS_PPC_PMC_G4
static struct device_attribute g4_common_attrs[] = {
	__ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
	__ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
	__ATTR(mmcr2, 0600, show_mmcr2, store_mmcr2),
};
#endif /* HAS_PPC_PMC_G4 */

static struct device_attribute classic_pmc_attrs[] = {
	__ATTR(pmc1, 0600, show_pmc1, store_pmc1),
	__ATTR(pmc2, 0600, show_pmc2, store_pmc2),
	int var;
       
	sscanf(buf, "%du", &var);
	
	if (strcmp(attr->attr.name, "major_no") == 0)
		 var=major_no ;
	else if (strcmp(attr->attr.name, "minor_no") == 0)
		var=minor_no ;
	else
		var=length;
	
	return count;
}
//--------------------------------------------------------------------------------------------

static struct kobj_attribute major_no_attribute = __ATTR(major_no, 0666, atrb_show, atrb_store);
static struct kobj_attribute minor_no_attribute = __ATTR(minor_no, 0666, atrb_show, atrb_store);
static struct kobj_attribute length_attribute = __ATTR(length, 0666, atrb_show, atrb_store);

static struct attribute *attrs[] = {
	&major_no_attribute.attr,
	&minor_no_attribute.attr,
	&length_attribute.attr,
	NULL,	/* need to NULL terminate the list of attributes */
};

static struct attribute_group attr_group = {
	.attrs = attrs,
};

/*--------------------------------------------------------------------------------------------
示例#12
0
		struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "version: %u.%u by faux123\n",
		DYN_FSYNC_VERSION_MAJOR,
		DYN_FSYNC_VERSION_MINOR);
}

static ssize_t dyn_fsync_earlysuspend_show(struct kobject *kobj,
		struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "early suspend active: %u\n", early_suspend_active);
}

static struct kobj_attribute dyn_fsync_active_attribute = 
	__ATTR(Dyn_fsync_active, 0666,
		dyn_fsync_active_show,
		dyn_fsync_active_store);

static struct kobj_attribute dyn_fsync_version_attribute = 
	__ATTR(Dyn_fsync_version, 0444, dyn_fsync_version_show, NULL);

static struct kobj_attribute dyn_fsync_earlysuspend_attribute = 
	__ATTR(Dyn_fsync_earlysuspend, 0444, dyn_fsync_earlysuspend_show, NULL);

static struct attribute *dyn_fsync_active_attrs[] =
	{
		&dyn_fsync_active_attribute.attr,
		&dyn_fsync_version_attribute.attr,
		&dyn_fsync_earlysuspend_attribute.attr,
		NULL,
	};
/* sysfs interface for "fast_charge_levels" */
static ssize_t available_charge_levels_show(struct kobject *kobj,
			struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%s\n", FAST_CHARGE_LEVELS);
}

/* sysfs interface for "version" */
static ssize_t version_show(struct kobject *kobj,
			struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "%s\n", FAST_CHARGE_VERSION);
}

static struct kobj_attribute version_attribute =
	__ATTR(version, 0444, version_show, NULL);

static struct kobj_attribute available_charge_levels_attribute =
	__ATTR(available_charge_levels, 0444,
		available_charge_levels_show, NULL);

static struct kobj_attribute fast_charge_level_attribute =
	__ATTR(fast_charge_level, 0666,
		charge_level_show,
		charge_level_store);

static struct kobj_attribute force_fast_charge_attribute =
	__ATTR(force_fast_charge, 0666,
		force_fast_charge_show,
		force_fast_charge_store);
示例#14
0
	mutex_lock(&c2dev->mutex);
	ret = __c2port_write_flash_data(c2dev, buffer, offset, count);
	mutex_unlock(&c2dev->mutex);

	if (ret < 0)
		dev_err(c2dev->dev, "cannot write %s flash\n", c2dev->name);

	return ret;
}

/*
 * Class attributes
 */

static struct device_attribute c2port_attrs[] = {
	__ATTR(name, 0444, c2port_show_name, NULL),
	__ATTR(flash_blocks_num, 0444, c2port_show_flash_blocks_num, NULL),
	__ATTR(flash_block_size, 0444, c2port_show_flash_block_size, NULL),
	__ATTR(flash_size, 0444, c2port_show_flash_size, NULL),
	__ATTR(access, 0644, c2port_show_access, c2port_store_access),
	__ATTR(reset, 0200, NULL, c2port_store_reset),
	__ATTR(dev_id, 0444, c2port_show_dev_id, NULL),
	__ATTR(rev_id, 0444, c2port_show_rev_id, NULL),

	__ATTR(flash_access, 0644, c2port_show_flash_access,
					c2port_store_flash_access),
	__ATTR(flash_erase, 0200, NULL, c2port_store_flash_erase),
	__ATTR_NULL,
};

static struct bin_attribute c2port_bin_attrs = {
示例#15
0
	switch (card->type) {
	case MMC_TYPE_MMC:
		return sprintf(buf, "MMC\n");
	case MMC_TYPE_SD:
		return sprintf(buf, "SD\n");
	case MMC_TYPE_SDIO:
		return sprintf(buf, "SDIO\n");
	case MMC_TYPE_SD_COMBO:
		return sprintf(buf, "SDcombo\n");
	default:
		return -EFAULT;
	}
}

static struct device_attribute mmc_dev_attrs[] = {
	__ATTR(type, S_IRUGO, mmc_type_show, NULL),
	__ATTR_NULL,
};

/*
 * This currently matches any MMC driver to any MMC card - drivers
 * themselves make the decision whether to drive this card in their
 * probe method.
 */
static int mmc_bus_match(struct device *dev, struct device_driver *drv)
{
	return 1;
}

static int
mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
/*sysfs write interface*/
static ssize_t ctrl_reg18_store(struct device *dev, struct device_attribute *attr,
		 const char *buf, size_t count)
{
	int ret;
	long val;
	ret = strict_strtol(buf, 10, &val);
	if (ret)
		return ret;
	val_SP_TX_LT_CTRL_REG18 = val;
	return count;
}
#endif
/* for debugging */
static struct device_attribute slimport_device_attrs[] = {
	__ATTR(rev_check, S_IRUGO | S_IWUSR, NULL, slimport7816_rev_check_store),
	__ATTR(hdcp_disable, S_IRUGO | S_IWUSR, sp_hdcp_feature_show, sp_hdcp_feature_store),
	__ATTR(hdcp_switch, S_IRUGO | S_IWUSR, sp_external_block_show, sp_external_block_store),
	__ATTR(hdmi_vga, S_IRUGO | S_IWUSR, slimport_sysfs_rda_hdmi_vga, NULL),
	__ATTR(anx7730, S_IRUGO | S_IWUSR, NULL, anx7730_write_reg_store),
	__ATTR(anx7816, S_IRUGO | S_IWUSR, NULL, anx7816_write_reg_store),
#ifdef SP_REGISTER_SET_TEST /*slimport test */
	__ATTR(ctrl_reg0, S_IRUGO | S_IWUSR, ctrl_reg0_show, ctrl_reg0_store),
	__ATTR(ctrl_reg10, S_IRUGO | S_IWUSR, ctrl_reg10_show, ctrl_reg10_store),
	__ATTR(ctrl_reg11, S_IRUGO | S_IWUSR, ctrl_reg11_show, ctrl_reg11_store),
	__ATTR(ctrl_reg2, S_IRUGO | S_IWUSR, ctrl_reg2_show, ctrl_reg2_store),
	__ATTR(ctrl_reg12, S_IRUGO | S_IWUSR, ctrl_reg12_show, ctrl_reg12_store),
	__ATTR(ctrl_reg1, S_IRUGO | S_IWUSR, ctrl_reg1_show, ctrl_reg1_store),
	__ATTR(ctrl_reg6, S_IRUGO | S_IWUSR, ctrl_reg6_show, ctrl_reg6_store),
	__ATTR(ctrl_reg16, S_IRUGO | S_IWUSR, ctrl_reg16_show, ctrl_reg16_store),
	__ATTR(ctrl_reg5, S_IRUGO | S_IWUSR, ctrl_reg5_show, ctrl_reg5_store),
static ssize_t store_technology(struct device *pdev,
				struct device_attribute *attr,
				const char *pbuf,
				size_t count);
static ssize_t store_temperature_ambient(struct device *pdev,
				 struct device_attribute *attr,
				 const char *pbuf,
				 size_t count);
#endif /* DEBUG_FS */

static ssize_t semc_battery_show_therm(struct device *dev,
					struct device_attribute *attr,
					char *buf);

static struct device_attribute semc_battery_attrs[] = {
	__ATTR(pmic_therm, S_IRUGO, semc_battery_show_therm, NULL),
	__ATTR(msm_therm, S_IRUGO, semc_battery_show_therm, NULL),
#ifdef DEBUG_FS
	__ATTR(set_temperature, S_IWUGO, NULL, store_temperature),
	__ATTR(set_technology, S_IWUGO, NULL, store_technology),
	__ATTR(set_temperature_ambient, S_IWUGO, NULL,
	       store_temperature_ambient),
#endif /* DEBUG_FS */
};

static int semc_battery_create_attrs(struct device *dev)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(semc_battery_attrs); i++)
		if (device_create_file(dev, &semc_battery_attrs[i]))
				 * change the scheduled time that's why we have to cancel it first.
				 */
				spin_lock_irqsave(&data->wq_lock, flags);

				__cancel_delayed_work(&data->als_dwork);

				spin_unlock_irqrestore(&data->wq_lock, flags);
			}
	}

	mutex_unlock(&data->update_lock);

	return count;
}

static struct device_attribute dev_attr_proximity_enable = __ATTR(enable, S_IWUSR | S_IWGRP | S_IRUGO,
				   tmd2771x_show_proximity_enable, tmd2771x_store_proximity_enable);

static ssize_t tmd2771x_show_light_enable(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", data->enable_als_sensor);
}

static ssize_t tmd2771x_store_light_enable(struct device *dev,
				struct device_attribute *attr, const char *buf, size_t count)
{
	struct i2c_client *client = data->client;
	unsigned long val = simple_strtoul(buf, NULL, 10);
	unsigned long flags;

	printk("%s: enable als sensor ( %ld)\n", __func__, val);
示例#19
0
	sscanf(buf, "%d", &newcurr);
	if(mswitch == 1 && newcurr <= MAX_VBUS_CURRENT)
		custom_current = newcurr;
	else
		pr_info("%s: disabled or limit reached, ignoring\n", THUNDERCHARGE);
	return count;
}

static ssize_t chgr_ver_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "Charger Control %u.%u", DRIVER_VERSION, DRIVER_SUBVER);
}

static struct kobj_attribute mswitch_attribute =
	__ATTR(enabled,
		0666,
		mswitch_show,
		mswitch_store);
		
static struct kobj_attribute chgr_ctrl_ver_attribute =
	__ATTR(version,
		0444,
		chgr_ver_show, NULL);

static struct kobj_attribute cust_ac_current_attribute =
	__ATTR(custom_current,
		0666,
		cust_ac_current_show,
		cust_ac_current_store);

static struct kobj_attribute cust_usb_current_attribute =
	__ATTR(custom_usb_current,
示例#20
0
文件: dmt08.c 项目: josh64x2/apc-rock
	if(error) {
		pr_err("%s strict_strtoul error\n", __FUNCTION__);
		return -1;
	}
	mutex_lock(&DMT_mutex);
	interval=(unsigned int)data;       
	mutex_unlock(&DMT_mutex);
	atomic_set(&delay, (unsigned int) data);
#if DMT_DEBUG_DATA
	printk("Driver attribute set delay =%lu\n",data);
#endif
	return 1;
}

static struct device_attribute DMT_attributes[] = {
	__ATTR(enable_acc, 0755, DMT_enable_acc_show, DMT_enable_acc_store),
	__ATTR(delay_acc,  0755, DMT_delay_acc_show,  DMT_delay_acc_store),
	__ATTR_NULL,
};

static int create_device_attributes(struct device *dev,	struct device_attribute *attrs)
{
	int i;
	int err = 0;
#if DMT_DEBUG_DATA
	IN_FUNC_MSG;
#endif	
	for (i = 0 ; NULL != attrs[i].attr.name ; ++i) {
		err = device_create_file(dev, &attrs[i]);
		if (0 != err)
			break;
		led_set_brightness(led_cdev, state);
	}

	return ret;
}

static ssize_t led_max_brightness_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct led_classdev *led_cdev = dev_get_drvdata(dev);

	return sprintf(buf, "%u\n", led_cdev->max_brightness);
}

static struct device_attribute led_class_attrs[] = {
	__ATTR(hand_flash, 0666, lcd_flashlight_show, lcd_flashlight_store),  // Archer_LSJ DB10
	__ATTR(lcd_gamma,  0666, lcd_gamma_show,      lcd_gamma_store),  // Archer_LSJ DA25
#ifdef SUPPORT_LCD_ACL_CTL
	__ATTR(acl_state,  0666, acl_state_show,      acl_state_store),     // ACL On/Off sysfs
#endif
	__ATTR(brightness, 0644, led_brightness_show, led_brightness_store),
	__ATTR(max_brightness, 0444, led_max_brightness_show, NULL),
#ifdef CONFIG_LEDS_TRIGGERS
	__ATTR(trigger, 0644, led_trigger_show, led_trigger_store),
#endif
	__ATTR_NULL,
};

/**
 * led_classdev_suspend - suspend an led_classdev.
 * @led_cdev: the led_classdev to suspend.
    TegraFuseSizeInBytes_SwReserved = 1, // 4 bit
    TegraFuseSizeInBytes_SkipDevSelStraps = 1,  // 1 bit
    TegraFuseSizeInBytes_SecBootDeviceSelectRaw = 4,
    TegraFuseSizeInBytes_ReservedOdm = 32
} TegraFuseSizeInBytes;


static ssize_t sysfsfuse_show(struct kobject *kobj,
        struct kobj_attribute *attr, char *buf);

static ssize_t sysfsfuse_store(struct kobject *kobj,
    struct kobj_attribute *attr, const char *buf, size_t count);


static struct kobj_attribute nvfuse_DeviceKey_attr =
    __ATTR(DeviceKey, 0440, sysfsfuse_show, sysfsfuse_store);

static struct kobj_attribute nvfuse_JtagDisable_attr =
    __ATTR(JtagDisable, 0440, sysfsfuse_show, sysfsfuse_store);

static struct kobj_attribute nvfuse_KeyProgrammed_attr =
    __ATTR(KeyProgrammed, 0440, sysfsfuse_show, sysfsfuse_store);

static struct kobj_attribute nvfuse_OdmProduction_attr =
    __ATTR(OdmProduction, 0440, sysfsfuse_show, sysfsfuse_store);

static struct kobj_attribute nvfuse_SecBootDeviceConfig_attr =
    __ATTR(SecBootDeviceConfig, 0440, sysfsfuse_show, sysfsfuse_store);

static struct kobj_attribute nvfuse_SecBootDeviceSelect_attr =
    __ATTR(SecBootDeviceSelect, 0440, sysfsfuse_show, sysfsfuse_store);
	ret = qpnp_vib_set(vib, vib->state);
	if (ret) {
		dev_err(dev, "%s: qpnp_vib_set failed %d\n", __func__, ret);
		vib->vtg_level = tmp_vtg_level;
		goto err_out;
	}

	return count;

err_out:
	return ret;
}

static struct device_attribute qpnp_vib_attr =
	__ATTR(qpnp_vib, S_IWUSR | S_IRUGO,
	qpnp_vib_attrs_show, qpnp_vib_attrs_store);

static int qpnp_vib_get_time(struct timed_output_dev *dev)
{
	struct qpnp_vib *vib = container_of(dev, struct qpnp_vib,
							 timed_dev);

	if (hrtimer_active(&vib->vib_timer)) {
		ktime_t r = hrtimer_get_remaining(&vib->vib_timer);
		return (int)ktime_to_us(r);
	}
	return 0;
}

static enum hrtimer_restart qpnp_vib_timer_func(struct hrtimer *timer)
{
示例#24
0
文件: sysfs.c 项目: 020gzh/linux
	return sprintf(buf, "%s\n", ppd->cc_prescan ? "on" : "off");
}

static ssize_t cc_prescan_store(struct hfi1_pportdata *ppd, const char *buf,
				size_t count)
{
	if (!memcmp(buf, "on", 2))
		ppd->cc_prescan = true;
	else if (!memcmp(buf, "off", 3))
		ppd->cc_prescan = false;

	return count;
}

static struct hfi1_port_attr cc_prescan_attr =
		__ATTR(cc_prescan, 0600, cc_prescan_show, cc_prescan_store);

static ssize_t cc_attr_show(struct kobject *kobj, struct attribute *attr,
			    char *buf)
{
	struct hfi1_port_attr *port_attr =
		container_of(attr, struct hfi1_port_attr, attr);
	struct hfi1_pportdata *ppd =
		container_of(kobj, struct hfi1_pportdata, pport_cc_kobj);

	return port_attr->show(ppd, buf);
}

static ssize_t cc_attr_store(struct kobject *kobj, struct attribute *attr,
			     const char *buf, size_t count)
{
示例#25
0
	if (frame_time_sum_init)
		goto DONE;

	now = ktime_get();
	timediff = (long) ktime_us_delta(now, last_flip);
	if (timediff > 1000000)
		goto DONE;

	frame_time_avg = frame_time_sum / EMA_PERIOD;
	fps = frame_time_avg > 0 ? 1000000 / frame_time_avg : 0;

DONE:
	return sprintf(buf, "%d\n", fps);
}

static struct global_attr fps_attr = __ATTR(fps, 0444,
		show_fps, NULL);

int __init throughput_init_miscdev(void)
{
	int ret;

	pr_debug("%s: initializing\n", __func__);

	spin_lock_init(&lock);
	INIT_WORK(&work, set_throughput_hint);

	ret = misc_register(&throughput_miscdev);
	if (ret) {
		pr_err("can\'t reigster throughput miscdev"
		       " (minor %d err %d)\n", TEGRA_THROUGHPUT_MINOR, ret);
		return ret;
示例#26
0
static ssize_t foo_show(struct foo_obj *foo_obj, struct foo_attribute *attr,
			char *buf)
{
	return sprintf(buf, "%d\n", foo_obj->foo);
}

static ssize_t foo_store(struct foo_obj *foo_obj, struct foo_attribute *attr,
			 const char *buf, size_t count)
{
	sscanf(buf, "%du", &foo_obj->foo);
	return count;
}

static struct foo_attribute foo_attribute =
	__ATTR(foo, 0666, foo_show, foo_store);

static ssize_t b_show(struct foo_obj *foo_obj, struct foo_attribute *attr,
		      char *buf)
{
	int var;

	if (strcmp(attr->attr.name, "baz") == 0)
		var = foo_obj->baz;
	else
		var = foo_obj->bar;
	return sprintf(buf, "%d\n", var);
}

static ssize_t b_store(struct foo_obj *foo_obj, struct foo_attribute *attr,
		       const char *buf, size_t count)
示例#27
0
	r_mixer_ptr->max = r_max;
	r_mixer_ptr->min += r_delta;
 
	return count;
}

static ssize_t sound_control_version_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
{
	return sprintf(buf, "version: %u.%u\n",
			SOUND_CONTROL_MAJOR_VERSION,
			SOUND_CONTROL_MINOR_VERSION);
}

static struct kobj_attribute cam_mic_gain_attribute =
	__ATTR(gpl_cam_mic_gain,
		0666,
		cam_mic_gain_show,
		cam_mic_gain_store);

static struct kobj_attribute mic_gain_attribute =
	__ATTR(gpl_mic_gain,
		0666,
		mic_gain_show,
		mic_gain_store);

static struct kobj_attribute speaker_gain_attribute =
	__ATTR(gpl_speaker_gain,
		0666,
		speaker_gain_show,
		speaker_gain_store);

static struct kobj_attribute headphone_gain_attribute = 
struct ss_musb_info {
    int jig_conn;
};

static struct ss_musb_info ss_musb_info_pdata;

enum
{
    SS_MUSB_INFO_ADC,
};

static ssize_t ss_musb_info_attrs_show(struct device *pdev, struct device_attribute *attr, char *buf);
static struct device_attribute ss_musb_info_attrs[]=
{
    __ATTR(adc, 0644, ss_musb_info_attrs_show, NULL),
};

static ssize_t ss_musb_info_attrs_show(struct device *pdev, struct device_attribute *attr, char *buf)
{
    ssize_t count = 0;
    int value=0;

    //struct ss_musb_info *pdata = (struct ss_musb_info *)pdev->platform_data;

    const ptrdiff_t off = attr-ss_musb_info_attrs;

    if(ss_musb_info_pdata.jig_conn == 1)
    {
        value = 0x1C; // jig connection mark.
    }
}

static ssize_t show_min_sample_time(struct kobject *kobj,
				struct attribute *attr, char *buf)
{
	return sprintf(buf, "%lu\n", min_sample_time);
}

static ssize_t store_min_sample_time(struct kobject *kobj,
			struct attribute *attr, const char *buf, size_t count)
{
	return strict_strtoul(buf, 0, &min_sample_time);
}

static struct global_attr min_sample_time_attr = __ATTR(min_sample_time, 0644,
		show_min_sample_time, store_min_sample_time);

static struct attribute *interactive_attributes[] = {
	&min_sample_time_attr.attr,
	NULL,
};

static struct attribute_group interactive_attr_group = {
	.attrs = interactive_attributes,
	.name = "interactive",
};

static int cpufreq_governor_interactive(struct cpufreq_policy *new_policy,
		unsigned int event)
{
	int rc;
示例#30
0
		return -EINVAL;
	}

	retval = rmi_write(rmi_dev, BSR_LOCATION, (u8)val);
	if (retval < 0) {
		dev_err(dev, "%s : failed to write bsr %lu to %#06x\n",
			__func__, val, BSR_LOCATION);
		return retval;
	}

	data->bsr = val;

	return count;
}

static struct device_attribute bsr_attribute = __ATTR(bsr, RMI_RW_ATTR,
	       rmi_driver_bsr_show, rmi_driver_bsr_store);

static int driver_ctl_cleanup(struct rmi_control_handler_data *hdata)
{
	struct device *dev = hdata->dev;
	struct rmi_device *rmi_dev = to_rmi_device(dev);
	struct rmi_driver_data *driver_data = dev_get_drvdata(&rmi_dev->dev);
	struct driver_ctl_data *ctl_data =
			container_of(hdata, struct driver_ctl_data, hdata);

	teardown_debugfs(ctl_data);

	if (driver_data->pdt_props.has_bsr)
		device_remove_file(&rmi_dev->dev, &bsr_attribute);

	devm_kfree(dev, ctl_data);