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;
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, };
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) {
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); }
* 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 = {
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, };
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, }; /*--------------------------------------------------------------------------------------------
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);
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 = {
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);
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,
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) {
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) {
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;
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)
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;
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);