コード例 #1
0
ファイル: br_sysfs_if.c プロジェクト: tidatida/lagopus
/*
 * 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);
}
コード例 #2
0
/*!
 * 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;
}
コード例 #3
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 ;
}
コード例 #4
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 ;
}
コード例 #5
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;
}
コード例 #6
0
ファイル: s5k6a2ya_v4l2.c プロジェクト: happyhere/802Xtreem
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 ;
}
コード例 #7
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;
}
コード例 #8
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 ;
}
コード例 #9
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;
}
コード例 #10
0
ファイル: coresight.c プロジェクト: 0x7678/SJKernel-gn2
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;
}
コード例 #11
0
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;
}
コード例 #12
0
static int __init cpufreq_stats_init(void)
{
	int ret;
	unsigned int cpu;

	spin_lock_init(&cpufreq_stats_lock);
	ret = cpufreq_register_notifier(&notifier_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(&notifier_trans_block,
				CPUFREQ_TRANSITION_NOTIFIER);
	if (ret) {
		cpufreq_unregister_notifier(&notifier_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;
}
コード例 #13
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;
}
コード例 #14
0
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;
}
コード例 #15
0
ファイル: mt_idle.c プロジェクト: JustAndroids/ZTEBladeL2
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__);
    }
}
コード例 #16
0
ファイル: imx219.c プロジェクト: kikokubo/SM-530T
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 ;
}
コード例 #17
0
ファイル: sysfs_attr.c プロジェクト: sky8336/mn201307
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;
}
コード例 #18
0
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;
}
コード例 #19
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;
}
コード例 #20
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;
}
コード例 #21
0
/* 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;
}
コード例 #22
0
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);
}
コード例 #23
0
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;
}
コード例 #24
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;
}
コード例 #25
0
ファイル: mce_amd_inj.c プロジェクト: CSCLOG/beaglebone
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;
}
コード例 #26
0
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;
}
コード例 #27
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;
}
コード例 #28
0
ファイル: bat_sysfs.c プロジェクト: AbheekG/XIA-for-Linux
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;
}
コード例 #29
0
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__);
    }
}
コード例 #30
0
ファイル: edac_device_sysfs.c プロジェクト: ANFS/ANFS-kernel
/*
 * 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;
}