/* * Add sysfs entries to ethernet device added to a bridge. * Creates a brport subdirectory with bridge attributes. * Puts symlink in bridge's brif subdirectory */ int br_sysfs_addif(struct net_bridge_port *p) { struct net_bridge *br = p->br; const struct brport_attribute **a; int err; err = sysfs_create_link(&p->kobj, &br->dev->dev.kobj, SYSFS_BRIDGE_PORT_LINK); if (err) { return err; } for (a = brport_attrs; *a; ++a) { err = sysfs_create_file(&p->kobj, &((*a)->attr)); if (err) { return err; } } strlcpy(p->sysfs_name, p->dev->name, IFNAMSIZ); return sysfs_create_link(br->ifobj, &p->kobj, p->sysfs_name); }
/*! * This is the probe routine for the lp_mode driver. * * @param pdev The platform device structure * * @return The function returns 0 on success * */ static int __devinit mx37_lpmode_probe(struct platform_device *pdev) { u32 res = 0; lpmode_dev = &pdev->dev; res = sysfs_create_file(&lpmode_dev->kobj, &dev_attr_lp_modes.attr); if (res) { printk(KERN_ERR "lpmode_dev: Unable to register sysdev entry for lpmode_dev"); return res; } if (res != 0) { printk(KERN_ERR "lpmode_dev: Unable to start"); return res; } lp_video_mode = 0; lp_audio_mode = 0; return 0; }
static int display_sysfs_init(void) { int ret ; printk(KERN_INFO "display_sysfs_init : kobject_create_and_add\n"); android_display = kobject_create_and_add("android_display", NULL); if (android_display == NULL) { printk(KERN_INFO "display_sysfs_init: subsystem_register " \ "failed\n"); ret = -ENOMEM; return ret ; } printk(KERN_INFO "display_sysfs_init : sysfs_create_file\n"); ret = sysfs_create_file(android_display, &dev_attr_panel.attr); if (ret) { printk(KERN_INFO "display_sysfs_init : sysfs_create_file " \ "failed\n"); kobject_del(android_display); } return 0 ; }
static int cam_get_awb_cal(void) { int ret ; /* Create /sys/android_camera_awb_cal/awb_cal */ cam_awb_cal = kobject_create_and_add("android_camera_awb_cal", NULL); if (cam_awb_cal == NULL) { pr_info("cam_get_awb_cal: subsystem_register failed\n"); ret = -ENOMEM; return ret ; } /* dev_attr_[register_name]<== DEVICE_ATTR(awb_cal, 0444, awb_calibration_show, NULL); */ ret = sysfs_create_file(cam_awb_cal, &dev_attr_awb_cal.attr); if (ret) { pr_info("cam_get_awb_cal:: sysfs_create_file failed\n"); kobject_del(cam_awb_cal); } return 0 ; }
int br_sysfs_addif(struct net_bridge_port *p) { struct net_bridge *br = p->br; struct brport_attribute **a; int err; err = sysfs_create_link(&p->kobj, &br->dev->dev.kobj, SYSFS_BRIDGE_PORT_LINK); if (err) goto out2; for (a = brport_attrs; *a; ++a) { err = sysfs_create_file(&p->kobj, &((*a)->attr)); if (err) goto out2; } err = sysfs_create_link(br->ifobj, &p->kobj, p->dev->name); out2: return err; }
static int s5k6a2ya_sysfs_init(void) { int ret ; pr_info("s5k6a2ya:kobject creat and add\n"); android_s5k6a2ya = kobject_create_and_add("android_camera2", NULL); if (android_s5k6a2ya == NULL) { pr_info("s5k6a2ya_sysfs_init: subsystem_register " \ "failed\n"); ret = -ENOMEM; return ret ; } pr_info("s5k6a2ya:sysfs_create_file\n"); ret = sysfs_create_file(android_s5k6a2ya, &dev_attr_sensor.attr); if (ret) { pr_info("s5k6a2ya_sysfs_init: sysfs_create_file " \ "failed\n"); kobject_del(android_s5k6a2ya); } return 0 ; }
int __init exynos_powermode_init(void) { store_boot_cpu_info(); if (IS_ENABLED(CONFIG_CPU_IDLE_EXYNOS)) exynos_idle_clock_down(true); init_cpd_state_mask(); exynos_lpm_dt_init(); exynos_pmu_cal_sys_init(); if (sysfs_create_file(power_kobj, &lpc_attribute.attr)) pr_err("%s: failed to create sysfs to control LPC\n", __func__); #ifdef CONFIG_ARM_EXYNOS_SMP_CPUFREQ disable_c3_idle = exynos_disable_cluster_power_down; #endif return 0; }
static int ov5693_sysfs_init(void) { int ret ; pr_info("ov5693:kobject creat and add\n"); android_ov5693 = kobject_create_and_add("android_camera", NULL); if (android_ov5693 == NULL) { pr_info("ov5693_sysfs_init: subsystem_register " \ "failed\n"); ret = -ENOMEM; return ret ; } pr_info("ov5693:sysfs_create_file\n"); ret = sysfs_create_file(android_ov5693, &dev_attr_sensor.attr); if (ret) { pr_info("ov5693_sysfs_init: sysfs_create_file " \ "failed\n"); kobject_del(android_ov5693); } return 0 ; }
static int ts_key_report_init(void) { int ret; virtual_key_kobj = kobject_get(android_touch_kobj); if (virtual_key_kobj == NULL) { virtual_key_kobj = kobject_create_and_add("board_properties", NULL); if (virtual_key_kobj == NULL) { printk(KERN_ERR "%s: subsystem_register failed\n", __func__); ret = -ENOMEM; return ret; } } ret = sysfs_create_file(virtual_key_kobj, &dev_attr_virtualkeys.attr); if (ret) { printk(KERN_ERR "%s: sysfs_create_file failed\n", __func__); return ret; } return 0; }
static int __init coresight_sysfs_init(void) { int ret; coresight.modulekobj = kset_find_obj(module_kset, KBUILD_MODNAME); if (!coresight.modulekobj) { pr_err("failed to find CORESIGHT sysfs module kobject\n"); ret = -ENOENT; goto err; } ret = sysfs_create_file(coresight.modulekobj, &max_clk_attr.attr); if (ret) { pr_err("failed to create CORESIGHT sysfs max_clk attribute\n"); goto err; } return 0; err: return ret; }
static int edac_device_add_main_sysfs_attributes( struct edac_device_ctl_info *edac_dev) { struct edac_dev_sysfs_attribute *sysfs_attrib; int err = 0; sysfs_attrib = edac_dev->sysfs_attributes; if (sysfs_attrib) { while (sysfs_attrib->attr.name != NULL) { err = sysfs_create_file(&edac_dev->kobj, (struct attribute*) sysfs_attrib); if (err) goto err_out; sysfs_attrib++; } } err_out: return err; }
static int __init cpufreq_stats_init(void) { int ret; unsigned int cpu; spin_lock_init(&cpufreq_stats_lock); ret = cpufreq_register_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); if (ret) return ret; register_hotcpu_notifier(&cpufreq_stat_cpu_notifier); for_each_online_cpu(cpu) cpufreq_update_policy(cpu); ret = cpufreq_register_notifier(¬ifier_trans_block, CPUFREQ_TRANSITION_NOTIFIER); if (ret) { cpufreq_unregister_notifier(¬ifier_policy_block, CPUFREQ_POLICY_NOTIFIER); unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier); for_each_online_cpu(cpu) cpufreq_stats_free_table(cpu); return ret; } create_all_freq_table(); for_each_possible_cpu(cpu) { cpufreq_allstats_create(cpu); } if (all_freq_table && all_freq_table->freq_table) sort(all_freq_table->freq_table, all_freq_table->table_size, sizeof(unsigned int), &compare_for_sort, NULL); ret = sysfs_create_file(cpufreq_global_kobject, &_attr_all_time_in_state.attr); if (ret) pr_warn("Error creating sysfs file for cpufreq stats\n"); return 0; }
static int rmi4_f54_create_sysfs_files(struct rmi4_function_device *fdev, bool create) { int i; int err = 0; for (i = 0; i < ARRAY_SIZE(rmi4_f54_attrs); i++) { if (create) err = sysfs_create_file(&fdev->dev.kobj, &rmi4_f54_attrs[i].attr); else sysfs_remove_file(&fdev->dev.kobj, &rmi4_f54_attrs[i].attr); if (err) { dev_err(&fdev->dev, "Failed to create sysfs files\n"); goto fail; } } if (create) { err = sysfs_create_bin_file(&fdev->dev.kobj, &rmi4_f54_rep_data); if (err) { dev_err(&fdev->dev, "Failed to create binary sysfs files\n"); goto fail; } } else { sysfs_remove_bin_file(&fdev->dev.kobj, &rmi4_f54_rep_data); } return err; fail: for (i--; i >= 0; i--) sysfs_remove_file(&fdev->dev.kobj, &rmi4_f54_attrs[i].attr); return err; }
static int rmi_f34_create_sysfs(struct rmi_function_dev *fn_dev) { int attr_count = 0; int rc; dev_dbg(&fn_dev->dev, "Creating sysfs files."); /* We need a sysfs file for the image/config block to write or read. * Set up sysfs bin file for binary data block. Since the image is * already in our format there is no need to convert the data for * endianess. */ rc = sysfs_create_bin_file(&fn_dev->dev.kobj, &dev_attr_data); if (rc < 0) { dev_err(&fn_dev->dev, "Failed to create sysfs file for F34 data, error=%d.\n", rc); return -ENODEV; } /* Set up sysfs device attributes. */ for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { if (sysfs_create_file (&fn_dev->dev.kobj, &attrs[attr_count].attr) < 0) { dev_err(&fn_dev->dev, "Failed to create sysfs file for %s.", attrs[attr_count].attr.name); rc = -ENODEV; goto err_remove_sysfs; } } return 0; err_remove_sysfs: sysfs_remove_bin_file(&fn_dev->dev.kobj, &dev_attr_data); for (attr_count--; attr_count >= 0; attr_count--) sysfs_remove_file(&fn_dev->dev.kobj, &attrs[attr_count].attr); return rc; }
void mt_idle_init(void) { int err = 0; idle_info("[%s]entry!!\n", __func__); arm_pm_idle = arch_idle; #ifndef SPM_SODI_ENABLED idle_switch[IDLE_TYPE_SO] = 0; #endif //92 deepidle keep use xgpt err = request_gpt(GPT4, GPT_ONE_SHOT, GPT_CLK_SRC_SYS, GPT_CLK_DIV_1, 0, NULL, GPT_NOAUTOEN); if (err) { idle_info("[%s]fail to request GPT4\n", __func__); } err = cpu_xgpt_register_timer(0,NULL); err |= cpu_xgpt_register_timer(1,NULL); err |= cpu_xgpt_register_timer(2,NULL); err |= cpu_xgpt_register_timer(3,NULL); err |= cpu_xgpt_register_timer(4,NULL); err |= cpu_xgpt_register_timer(5,NULL); err |= cpu_xgpt_register_timer(6,NULL); err |= cpu_xgpt_register_timer(7,NULL); if (err) { idle_info("[%s]fail to request cpuxgpt\n", __func__); } err = sysfs_create_file(power_kobj, &idle_state_attr.attr); #ifdef SPM_SODI_ENABLED err |= sysfs_create_file(power_kobj, &soidle_state_attr.attr); #endif #ifdef SPM_MCDI_FUNC err |= sysfs_create_file(power_kobj, &mcidle_state_attr.attr); #endif err |= sysfs_create_file(power_kobj, &dpidle_state_attr.attr); err |= sysfs_create_file(power_kobj, &slidle_state_attr.attr); err |= sysfs_create_file(power_kobj, &rgidle_state_attr.attr); if (err) { idle_err("[%s]: fail to create sysfs\n", __func__); } }
static int imx219_sysfs_init(void) { int ret ; pr_info("%s: imx219:kobject creat and add\n", __func__); android_imx219 = kobject_create_and_add("android_camera", NULL); if (android_imx219 == NULL) { pr_info("imx219_sysfs_init: subsystem_register " \ "failed\n"); ret = -ENOMEM; return ret ; } pr_info("imx219:sysfs_create_file\n"); ret = sysfs_create_file(android_imx219, &dev_attr_sensor.attr); if (ret) { pr_info("imx219_sysfs_init: sysfs_create_file " \ "failed\n"); kobject_del(android_imx219); } return 0 ; }
static int __init mntest_init(void) { int ret; #ifdef SYSFS_ATTR_CREATE /* * Create a simple kobject with the name of "mntest", * located under /sys/kernel/ **/ mntest_kobj = kobject_create_and_add("mntest", kernel_kobj); if (!mntest_kobj) return -ENOMEM; ret = sysfs_create_file(mntest_kobj, &test_value_attribute); if (ret) kobject_put(mntest_kobj); #endif printk("%s:%d\n", __func__, __LINE__); return ret; }
static int create_test_nodes(int size, struct kobject *parent_kobj) { int i, j; int retval = 0; char *name; //struct attribute *temp_attr; //char test_mode[][DEVNAME_SIZE] = {"DATA_READ", "DATA_WRITE", "CMD"}; //int test_mode_count = sizeof(test_mode)/sizeof(test_mode[0]); test_attrs = kzalloc(TEST_MODE_COUNT * size * sizeof(struct attribute*), GFP_KERNEL); test_kattr = kzalloc(TEST_MODE_COUNT * size * sizeof(struct kobj_attribute*), GFP_KERNEL); tmode_kobj = kzalloc(size * sizeof(struct kobject*), GFP_KERNEL); for(i=0; i<size; i++){ name = kzalloc(DEVNAME_SIZE, GFP_KERNEL); sprintf(name, "%d", i); tmode_kobj[i] = kobject_create_and_add(name, parent_kobj); if (tmode_kobj[i] == NULL) return -ENOMEM; for(j=0; j<TEST_MODE_COUNT; j++){ test_attrs[i*TEST_MODE_COUNT+j] = kzalloc(sizeof(struct attribute), GFP_KERNEL); test_kattr[i*TEST_MODE_COUNT+j] = kzalloc(sizeof(struct kobj_attribute), GFP_KERNEL); name = kzalloc(DEVNAME_SIZE, GFP_KERNEL); sprintf(name, "%s", test_mode[j]); test_attrs[i*TEST_MODE_COUNT+j]->name = name; test_attrs[i*TEST_MODE_COUNT+j]->mode = 0777; test_kattr[i*TEST_MODE_COUNT+j]->attr = *test_attrs[i*TEST_MODE_COUNT+j];//*temp_attr; test_kattr[i*TEST_MODE_COUNT+j]->show = test_show; test_kattr[i*TEST_MODE_COUNT+j]->store = test_store; //test_attrs[i*TEST_MODE_COUNT+j] = &test_kattr[i*TEST_MODE_COUNT+j]->attr; retval = sysfs_create_file(tmode_kobj[i], &test_kattr[i*TEST_MODE_COUNT+j]->attr); if (retval) kobject_put(tmode_kobj[i]); } } return 0; }
int init_module(void) { int ret; ProcBuffer = vmalloc(sizeof(char)*MAXDATASIZE); if(ProcBuffer == NULL) { return -ENOMEM; } memset(ProcBuffer,0,sizeof(char)*MAXDATASIZE); WritingLength = 0; /* Procfs setting */ /* if( (proc_mtd = create_proc_entry("htc_monitor", 0444, NULL)) ) { proc_mtd->proc_fops = &log_proc_ops; } */ proc_mtd = proc_create_data("htc_monitor", 0444, NULL, &log_proc_ops, NULL); if (proc_mtd == NULL) { pr_info("proc_create_data is null\n"); } /* Attribute file setting */ htc_monitor_status_obj = kobject_create_and_add("htc_monitor_status", NULL); if (htc_monitor_status_obj == NULL) { pr_info("kobject_create_and_add: htc_monitor_status failed\n"); return -EFAULT; } ret = sysfs_create_file(htc_monitor_status_obj, &dev_attr_htc_monitor_param.attr); if (ret) { pr_info("sysfs_create_file: dev_attr_htc_monitor_param failed\n"); return -EFAULT; } return 0; }
static int __init enhance_init(void) { int retval; int attr_count = 0; enhance__kobj = kobject_create_and_add("lcd_enhance", kernel_kobj); if (!enhance__kobj) return -ENOMEM; /* Create the files associated with this kobject */ for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) { if(!zte_enhance_val.en_colortmp && (attr_count == 1)) continue; retval = sysfs_create_file(enhance__kobj, &attrs[attr_count].attr); if (retval < 0) { pr_err("%s: Failed to create sysfs attributes\n", __func__); goto err_sys; } } pr_info("lcd: %s Done.\n",__func__); return retval; err_sys: for (attr_count--; attr_count >= 0; attr_count--) { sysfs_remove_file(enhance__kobj, &attrs[attr_count].attr); } kobject_put(enhance__kobj); pr_info("lcd: %s init ERR.\n",__func__); return retval; }
/* Module registration */ static int __init phonet_init(void) { int err; #ifdef ACTIVATE_PHONET_DEBUG err = sysfs_create_file(kernel_kobj, &phonet_attr.attr); if (err) printk(KERN_DEBUG "phonet sysfs_create_file failed: %d\n", err); #endif err = phonet_device_init(); if (err) return err; pn_sock_init(); err = sock_register(&phonet_proto_family); if (err) { printk(KERN_ALERT "phonet protocol family initialization failed\n"); goto err_sock; } dev_add_pack(&phonet_packet_type); phonet_sysctl_init(); err = isi_register(); if (err) goto err; return 0; err: phonet_sysctl_exit(); sock_unregister(PF_PHONET); dev_remove_pack(&phonet_packet_type); err_sock: phonet_device_exit(); return err; }
static inline int kobject_add_complete(struct kobject *kobj, struct kobject *parent) { struct kobj_type *t; int error; kobj->parent = kobject_get(parent); error = sysfs_create_dir(kobj); if (error == 0 && kobj->ktype && kobj->ktype->default_attrs) { struct attribute **attr; t = kobj->ktype; for (attr = t->default_attrs; *attr != NULL; attr++) { error = sysfs_create_file(kobj, *attr); if (error) break; } if (error) sysfs_remove_dir(kobj); } return (error); }
static int cap_ts_vkeys_init(void) { int rc,i; struct kobject * cap_ts_properties_kobj=NULL; cap_ts_properties_kobj = kobject_create_and_add("board_properties", NULL); if (cap_ts_properties_kobj == NULL) { printk("%s: subsystem_register failed\n", __func__); rc = -ENOMEM; return rc; } android_touch_kobj = cap_ts_properties_kobj; for ( i=0; i < ARRAY_SIZE(cap_ts_device_attr); i++ ){ rc = sysfs_create_file(cap_ts_properties_kobj, &cap_ts_device_attr[i].attr); if (rc) { printk("%s: sysfs_create_file failed\n", __func__); return rc; } } return 0; }
static int create_sysfs_entry(void *_ctx, struct mlx4_ib_iov_sysfs_attr *_dentry, char *_name, struct kobject *_kobj, ssize_t (*show)(struct device *dev, struct device_attribute *attr, char *buf), ssize_t (*store)(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) ) { int ret = 0; struct mlx4_ib_iov_sysfs_attr *vdentry = _dentry; vdentry->ctx = _ctx; vdentry->dentry.show = show; vdentry->dentry.store = store; sysfs_attr_init(&vdentry->dentry.attr); vdentry->dentry.attr.name = vdentry->name; vdentry->dentry.attr.mode = 0; vdentry->kobj = _kobj; snprintf(vdentry->name, 15, "%s", _name); if (vdentry->dentry.store) vdentry->dentry.attr.mode |= S_IWUSR; if (vdentry->dentry.show) vdentry->dentry.attr.mode |= S_IRUGO; ret = sysfs_create_file(vdentry->kobj, &vdentry->dentry.attr); if (ret) { pr_err("failed to create %s\n", vdentry->dentry.attr.name); vdentry->ctx = NULL; return ret; } return ret; }
static int __init edac_init_mce_inject(void) { struct sysdev_class *edac_class = NULL; int i, err = 0; edac_class = edac_get_sysfs_class(); if (!edac_class) return -EINVAL; mce_kobj = kobject_create_and_add("mce", &edac_class->kset.kobj); if (!mce_kobj) { printk(KERN_ERR "Error creating a mce kset.\n"); err = -ENOMEM; goto err_mce_kobj; } for (i = 0; i < ARRAY_SIZE(sysfs_attrs); i++) { err = sysfs_create_file(mce_kobj, &sysfs_attrs[i]->attr); if (err) { printk(KERN_ERR "Error creating %s in sysfs.\n", sysfs_attrs[i]->attr.name); goto err_sysfs_create; } } return 0; err_sysfs_create: while (--i >= 0) sysfs_remove_file(mce_kobj, &sysfs_attrs[i]->attr); kobject_del(mce_kobj); err_mce_kobj: edac_put_sysfs_class(); return err; }
static int create_stage1_nodes(int size, struct kobject *parent_kobj) { #define NODE_COUNT (TOTAL_STAGE1_NODE_COUNT) int i, j; int retval = 0; char *name; stage1_attrs = kzalloc(NODE_COUNT * size * sizeof(struct attribute*), GFP_KERNEL); stage1_kattr = kzalloc(NODE_COUNT * size * sizeof(struct kobj_attribute*), GFP_KERNEL); s1_host_kobj = kzalloc(size * sizeof(struct kobject*), GFP_KERNEL); for(i=0; i<size; i++){ name = kzalloc(DEVNAME_SIZE, GFP_KERNEL); sprintf(name, "%d", i); s1_host_kobj[i] = kobject_create_and_add(name, parent_kobj); if (s1_host_kobj[i] == NULL) return -ENOMEM; for(j=0; j<NODE_COUNT; j++){ stage1_attrs[i*NODE_COUNT+j] = kzalloc(sizeof(struct attribute), GFP_KERNEL); stage1_kattr[i*NODE_COUNT+j] = kzalloc(sizeof(struct kobj_attribute), GFP_KERNEL); //name = kzalloc(DEVNAME_SIZE, GFP_KERNEL); //sprintf(name, "%s", args_type[j]); stage1_attrs[i*NODE_COUNT+j]->name = stage1_nodes[j]; stage1_attrs[i*NODE_COUNT+j]->mode = 0660; stage1_kattr[i*NODE_COUNT+j]->attr = *stage1_attrs[i*NODE_COUNT+j];//*temp_attr; stage1_kattr[i*NODE_COUNT+j]->show = stage1_show; stage1_kattr[i*NODE_COUNT+j]->store = stage1_store; sysfs_attr_init(&stage1_kattr[i*NODE_COUNT+j]->attr); retval = sysfs_create_file(s1_host_kobj[i], &stage1_kattr[i*NODE_COUNT+j]->attr); if (retval) kobject_put(s1_host_kobj[i]); } } p_autok_thread_data->is_autok_done = kzalloc(sizeof(u8)*size, GFP_KERNEL); cur_voltage = kzalloc(sizeof(u32)*size, GFP_KERNEL); p_single_autok = kzalloc(sizeof(struct autok_predata)*size, GFP_KERNEL); return 0; }
static int __devinit mipi_nt35510_lcd_probe(struct platform_device *pdev) { struct platform_device *msm_fb_pdev; struct lcd_device *lcd_device; int ret; DPRINT("%s\n", __func__); if (pdev->id == 0) { mipi_nt35510_pdata = pdev->dev.platform_data; return 0; } /* * save returned struct platform_device pointer * as we later need to get msm_fb_data_type */ msm_fb_pdev = msm_fb_add_device(pdev); /* struct lcd_device now has needed platform data */ lcd_device = lcd_device_register("panel", &pdev->dev, platform_get_drvdata(msm_fb_pdev), &mipi_lcd_props); if (IS_ERR(lcd_device)) { ret = PTR_ERR(lcd_device); printk(KERN_ERR "lcd : failed to register device\n"); return ret; } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_type.attr); if (ret) printk(KERN_ERR "sysfs create fail - %s\n", dev_attr_lcd_type.attr.name); return 0; }
int sysfs_add_meshif(struct net_device *dev) { struct kobject *batif_kobject = &dev->dev.kobj; struct bat_priv *bat_priv = netdev_priv(dev); struct bat_attribute **bat_attr; int err; bat_priv->mesh_obj = kobject_create_and_add(SYSFS_IF_MESH_SUBDIR, batif_kobject); if (!bat_priv->mesh_obj) { bat_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name, SYSFS_IF_MESH_SUBDIR); goto out; } for (bat_attr = mesh_attrs; *bat_attr; ++bat_attr) { err = sysfs_create_file(bat_priv->mesh_obj, &((*bat_attr)->attr)); if (err) { bat_err(dev, "Can't add sysfs file: %s/%s/%s\n", dev->name, SYSFS_IF_MESH_SUBDIR, ((*bat_attr)->attr).name); goto rem_attr; } } return 0; rem_attr: for (bat_attr = mesh_attrs; *bat_attr; ++bat_attr) sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr)); kobject_put(bat_priv->mesh_obj); bat_priv->mesh_obj = NULL; out: return -ENOMEM; }
void mt_idle_init(void) { int err = 0; int i = 0; CHIP_SW_VER ver=mt_get_chip_sw_ver(); if(CHIP_SW_VER_02<=ver) { memcpy(idle_switch,idle_switch_E2,sizeof(idle_switch)); //return;//TODO,for E2 default off arch_idle } idle_info("[%s]entry!!\n", __func__); arm_pm_idle = arch_idle; err = request_gpt(idle_gpt, GPT_ONE_SHOT, GPT_CLK_SRC_SYS, GPT_CLK_DIV_1, 0, NULL, GPT_NOAUTOEN); if (err) { idle_info("[%s]fail to request GPT%d\n", __func__,idle_gpt+1); } err = 0; for(i=0;i<NR_CPUS;i++){ err |= cpu_xgpt_register_timer(i,NULL); } if (err) { idle_info("[%s]fail to request cpuxgpt\n", __func__); } err = sysfs_create_file(power_kobj, &idle_state_attr.attr); err |= sysfs_create_file(power_kobj, &soidle_state_attr.attr); err |= sysfs_create_file(power_kobj, &mcidle_state_attr.attr); err |= sysfs_create_file(power_kobj, &dpidle_state_attr.attr); err |= sysfs_create_file(power_kobj, &slidle_state_attr.attr); err |= sysfs_create_file(power_kobj, &rgidle_state_attr.attr); if (err) { idle_err("[%s]: fail to create sysfs\n", __func__); } }
/* * edac_device_add_main_sysfs_attributes * add some attributes to this instance's main kobject */ static int edac_device_add_main_sysfs_attributes( struct edac_device_ctl_info *edac_dev) { struct edac_dev_sysfs_attribute *sysfs_attrib; int err = 0; sysfs_attrib = edac_dev->sysfs_attributes; if (sysfs_attrib) { /* iterate over the array and create an attribute for each * entry in the list */ while (sysfs_attrib->attr.name != NULL) { err = sysfs_create_file(&edac_dev->kobj, (struct attribute*) sysfs_attrib); if (err) goto err_out; sysfs_attrib++; } } err_out: return err; }