コード例 #1
0
static int __init inv_pthread_init(void)
{
    int retval;

    status_kobj = kzalloc(sizeof(*status_kobj), GFP_KERNEL);
    if(!status_kobj)
        return PTR_ERR(status_kobj);

    status_kset = kset_create_and_add("platform_status", NULL, kernel_kobj);
    if(!status_kset)
        return -1;

    status_kobj->kset = status_kset;

    retval = kobject_init_and_add(status_kobj, &status_ktype, NULL, "fan");
    if(retval)
        return retval;

    retval = sysfs_create_file(status_kobj, &status_att);

    thread_control_set(1);

    printk(KERN_INFO "[p_thread] %s/%d: Creating Thread\n",__func__,__LINE__);
    //Create the kernel thread with name 'inv_pthread'
    thread_st = kthread_run(thread_fn, (void*)&thread_data, "inv_pthread");
    if (thread_st)
        printk(KERN_INFO "[p_thread] inv_pthread Created successfully\n");
    else
        printk(KERN_ERR "[p_thread] inv_pthread creation failed\n");

    return retval;
}
コード例 #2
0
static int __init devicemodeldemo_init(void)
{
	printk(KERN_ALERT "DeviceModelDemo: Entry devicemodeldemo_init !\n");

	kobject_init_and_add( &dmdkobj, &dmdkobj_type, NULL, "devicemodeldemo" );

	return 0;
}
コード例 #3
0
int punit_create_sys_info(fw_info_t *fw_info)
{
	int retval = 0;
	retval = kobject_init_and_add(&fw_info->fw_info_kobj, &ktype, &(THIS_MODULE->mkobj.kobj), "fw_info");
	if (retval != 0)
		printk(KERN_ERR "Kobject create failed: (%s)\n", __FUNCTION__);
	return retval;
}
コード例 #4
0
/*
 * edac_device_register_sysfs_main_kobj
 *
 *	perform the high level setup for the new edac_device instance
 *
 * Return:  0 SUCCESS
 *         !0 FAILURE
 */
int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev)
{
	struct sysdev_class *edac_class;
	int err;

	debugf1("%s()\n", __func__);

	/* get the /sys/devices/system/edac reference */
	edac_class = edac_get_edac_class();
	if (edac_class == NULL) {
		debugf1("%s() no edac_class error\n", __func__);
		err = -ENODEV;
		goto err_out;
	}

	/* Point to the 'edac_class' this instance 'reports' to */
	edac_dev->edac_class = edac_class;

	/* Init the devices's kobject */
	memset(&edac_dev->kobj, 0, sizeof(struct kobject));

	/* Record which module 'owns' this control structure
	 * and bump the ref count of the module
	 */
	edac_dev->owner = THIS_MODULE;

	if (!try_module_get(edac_dev->owner)) {
		err = -ENODEV;
		goto err_out;
	}

	/* register */
	err = kobject_init_and_add(&edac_dev->kobj, &ktype_device_ctrl,
				   &edac_class->kset.kobj,
				   "%s", edac_dev->name);
	if (err) {
		debugf1("%s()Failed to register '.../edac/%s'\n",
			__func__, edac_dev->name);
		goto err_kobj_reg;
	}
	kobject_uevent(&edac_dev->kobj, KOBJ_ADD);

	/* At this point, to 'free' the control struct,
	 * edac_device_unregister_sysfs_main_kobj() must be used
	 */

	debugf4("%s() Registered '.../edac/%s' kobject\n",
		__func__, edac_dev->name);

	return 0;

	/* Error exit stack */
err_kobj_reg:
	module_put(edac_dev->owner);

err_out:
	return err;
}
コード例 #5
0
ファイル: nand_test_dev.c プロジェクト: alex-deng/a33_linux
/*****************************************************************************
*Name         :
*Description  :
*Parameter    :
*Return       :
*Note         :
*****************************************************************************/
int add_nand_for_test(struct _nand_phy_partition* phy_partition)
{
	int i;
    __u32 cur_offset = 0;
    struct _nftl_blk *nftl_blk;
    struct _nand_dev *nand_dev;
	struct _nand_disk* disk;
	struct _nand_disk* head_disk;
	struct nand_kobject* nand_kobj;
	uint16 PartitionNO;

    PartitionNO = get_partitionNO(phy_partition);

    nftl_blk = kmalloc(sizeof(struct _nftl_blk), GFP_KERNEL);
    if (!nftl_blk)
	{
	    printk("nftl_blk kmalloc fail!\n");
		return 1;
	}
    nftl_blk->nand = build_nand_partition(phy_partition);

    if (nftl_initialize(nftl_blk,PartitionNO))
	{
        printk("nftl_initialize failed\n");
        return 1;
    }

    nftl_blk->blk_lock = kmalloc(sizeof(struct mutex), GFP_KERNEL);
    if (!nftl_blk->blk_lock)
	{
	    printk("blk_lock kmalloc fail!\n");
		return 1;
	}
    mutex_init(nftl_blk->blk_lock);

	nftl_blk->nftl_thread = kthread_run(nftl_test_thread, nftl_blk, "%sd", "nftl");
    if (IS_ERR(nftl_blk->nftl_thread))
    {
        printk("nftl_thread kthread_run fail!\n");
        return 1;
    }

    add_nftl_blk_list(&nftl_blk_head,nftl_blk);

    nand_kobj = kzalloc(sizeof(struct nand_kobject), GFP_KERNEL);
    if (!nand_kobj)
	{
	    printk("nand_kobj kzalloc fail!\n");
		return 1;
	}
	nand_kobj->nftl_blk = nftl_blk;
    if(kobject_init_and_add(&nand_kobj->kobj,&ktype,NULL,"nand_driver%d",PartitionNO) != 0 ) {
	printk("init nand sysfs fail!\n");
		return 1;
	}

    return 0;
}
コード例 #6
0
ファイル: sysfsDemo.c プロジェクト: bradacina/LinuxDocs
static __init int hello_init(void)
{
	int error = kobject_init_and_add(&dirKobj, &dirKtype, kernel_kobj,
			"%s", DIR_NAME);
	if (error < 0)
		return error;

	return error;
}
コード例 #7
0
ファイル: sysfs.c プロジェクト: Arseny-N/fgfs
int gfs_sysfs_init_sb(struct gfs_super_info *sbi)
{
	struct super_block *sb = sbi->s_vfs_sb;
	int err = 0;
	BUG_ON(!gfs_kset);
	sbi->s_kobj.kset = gfs_kset;
	err = kobject_init_and_add(&sbi->s_kobj, &gfs_ktype, NULL, "%s", sb->s_id);

	return err;
}
コード例 #8
0
ファイル: owl_gpu_clk.c プロジェクト: xapp-le/kernel
/* add 5 attributes to /sys/devices/b0300000.gpu/pvrsrv */
int owl_gpu_fun_add_attr(struct kobject *dev_kobj)
{
	int err=0;
	err = kobject_init_and_add(&owl_gpu.kobj,&gpu_ktype,dev_kobj,"pvrsrv");
	if (err) 
	{
		printk("failed to create sysfs file\n");
	}
	return err;
}
コード例 #9
0
int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev)
{
	struct bus_type *edac_subsys;
	int err;

	debugf1("%s()\n", __func__);

	
	edac_subsys = edac_get_sysfs_subsys();
	if (edac_subsys == NULL) {
		debugf1("%s() no edac_subsys error\n", __func__);
		err = -ENODEV;
		goto err_out;
	}

	
	edac_dev->edac_subsys = edac_subsys;

	
	memset(&edac_dev->kobj, 0, sizeof(struct kobject));

	edac_dev->owner = THIS_MODULE;

	if (!try_module_get(edac_dev->owner)) {
		err = -ENODEV;
		goto err_mod_get;
	}

	
	err = kobject_init_and_add(&edac_dev->kobj, &ktype_device_ctrl,
				   &edac_subsys->dev_root->kobj,
				   "%s", edac_dev->name);
	if (err) {
		debugf1("%s()Failed to register '.../edac/%s'\n",
			__func__, edac_dev->name);
		goto err_kobj_reg;
	}
	kobject_uevent(&edac_dev->kobj, KOBJ_ADD);


	debugf4("%s() Registered '.../edac/%s' kobject\n",
		__func__, edac_dev->name);

	return 0;

	
err_kobj_reg:
	module_put(edac_dev->owner);

err_mod_get:
	edac_put_sysfs_subsys();

err_out:
	return err;
}
コード例 #10
0
ファイル: iommu.c プロジェクト: ramlaxman/linux
/**
 * iommu_group_alloc - Allocate a new group
 * @name: Optional name to associate with group, visible in sysfs
 *
 * This function is called by an iommu driver to allocate a new iommu
 * group.  The iommu group represents the minimum granularity of the iommu.
 * Upon successful return, the caller holds a reference to the supplied
 * group in order to hold the group until devices are added.  Use
 * iommu_group_put() to release this extra reference count, allowing the
 * group to be automatically reclaimed once it has no devices or external
 * references.
 */
struct iommu_group *iommu_group_alloc(void)
{
	struct iommu_group *group;
	int ret;

	group = kzalloc(sizeof(*group), GFP_KERNEL);
	if (!group)
		return ERR_PTR(-ENOMEM);

	group->kobj.kset = iommu_group_kset;
	mutex_init(&group->mutex);
	INIT_LIST_HEAD(&group->devices);
	BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);

	mutex_lock(&iommu_group_mutex);

again:
	if (unlikely(0 == ida_pre_get(&iommu_group_ida, GFP_KERNEL))) {
		kfree(group);
		mutex_unlock(&iommu_group_mutex);
		return ERR_PTR(-ENOMEM);
	}

	if (-EAGAIN == ida_get_new(&iommu_group_ida, &group->id))
		goto again;

	mutex_unlock(&iommu_group_mutex);

	ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype,
				   NULL, "%d", group->id);
	if (ret) {
		mutex_lock(&iommu_group_mutex);
		ida_remove(&iommu_group_ida, group->id);
		mutex_unlock(&iommu_group_mutex);
		kfree(group);
		return ERR_PTR(ret);
	}

	group->devices_kobj = kobject_create_and_add("devices", &group->kobj);
	if (!group->devices_kobj) {
		kobject_put(&group->kobj); /* triggers .release & free */
		return ERR_PTR(-ENOMEM);
	}

	/*
	 * The devices_kobj holds a reference on the group kobject, so
	 * as long as that exists so will the group.  We can therefore
	 * use the devices_kobj for reference counting.
	 */
	kobject_put(&group->kobj);

	pr_debug("Allocated group %d\n", group->id);

	return group;
}
コード例 #11
0
void dss_init_overlays(struct platform_device *pdev)
{
	int i, r;

	num_overlays = dss_feat_get_num_ovls();

	overlays = kzalloc(sizeof(struct omap_overlay) * num_overlays,
			GFP_KERNEL);

	BUG_ON(overlays == NULL);

	for (i = 0; i < num_overlays; ++i) {
		struct omap_overlay *ovl = &overlays[i];

		switch (i) {
		case 0:
			ovl->name = "gfx";
			ovl->id = OMAP_DSS_GFX;
			break;
		case 1:
			ovl->name = "vid1";
			ovl->id = OMAP_DSS_VIDEO1;
			break;
		case 2:
			ovl->name = "vid2";
			ovl->id = OMAP_DSS_VIDEO2;
			break;
		case 3:
			ovl->name = "vid3";
			ovl->id = OMAP_DSS_VIDEO3;
			break;
		}

		ovl->is_enabled = &dss_ovl_is_enabled;
		ovl->enable = &dss_ovl_enable;
		ovl->disable = &dss_ovl_disable;
		ovl->set_manager = &dss_ovl_set_manager;
		ovl->unset_manager = &dss_ovl_unset_manager;
		ovl->set_overlay_info = &dss_ovl_set_info;
		ovl->get_overlay_info = &dss_ovl_get_info;
		ovl->wait_for_go = &dss_mgr_wait_for_go_ovl;

		ovl->caps = dss_feat_get_overlay_caps(ovl->id);
		ovl->supported_modes =
			dss_feat_get_supported_color_modes(ovl->id);

		r = kobject_init_and_add(&ovl->kobj, &overlay_ktype,
				&pdev->dev.kobj, "overlay%d", i);

		if (r)
			DSSERR("failed to create sysfs file\n");
	}
}
コード例 #12
0
ファイル: edac_device_sysfs.c プロジェクト: 020gzh/linux
/*
 * edac_device_register_sysfs_main_kobj
 *
 *	perform the high level setup for the new edac_device instance
 *
 * Return:  0 SUCCESS
 *         !0 FAILURE
 */
int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev)
{
	struct bus_type *edac_subsys;
	int err;

	edac_dbg(1, "\n");

	/* get the /sys/devices/system/edac reference */
	edac_subsys = edac_get_sysfs_subsys();

	/* Point to the 'edac_subsys' this instance 'reports' to */
	edac_dev->edac_subsys = edac_subsys;

	/* Init the devices's kobject */
	memset(&edac_dev->kobj, 0, sizeof(struct kobject));

	/* Record which module 'owns' this control structure
	 * and bump the ref count of the module
	 */
	edac_dev->owner = THIS_MODULE;

	if (!try_module_get(edac_dev->owner)) {
		err = -ENODEV;
		goto err_out;
	}

	/* register */
	err = kobject_init_and_add(&edac_dev->kobj, &ktype_device_ctrl,
				   &edac_subsys->dev_root->kobj,
				   "%s", edac_dev->name);
	if (err) {
		edac_dbg(1, "Failed to register '.../edac/%s'\n",
			 edac_dev->name);
		goto err_kobj_reg;
	}
	kobject_uevent(&edac_dev->kobj, KOBJ_ADD);

	/* At this point, to 'free' the control struct,
	 * edac_device_unregister_sysfs_main_kobj() must be used
	 */

	edac_dbg(4, "Registered '.../edac/%s' kobject\n", edac_dev->name);

	return 0;

	/* Error exit stack */
err_kobj_reg:
	module_put(edac_dev->owner);

err_out:
	return err;
}
コード例 #13
0
int kgsl_pwrscale_init(struct kgsl_device *device)
{
	int ret;

	ret = kobject_init_and_add(&device->pwrscale_kobj, &ktype_pwrscale,
		&device->dev->kobj, "pwrscale");

	if (ret)
		return ret;

	kobject_init(&device->pwrscale.kobj, &ktype_pwrscale_policy);
	return ret;
}
コード例 #14
0
int sysaufs_si_init(struct au_sbinfo *sbinfo)
{
	int err;

	sbinfo->si_kobj.kset = au_kset;
	/* some people doesn't like to show a pointer in kernel */
	err = kobject_init_and_add(&sbinfo->si_kobj, &au_sbi_ktype,
				   NULL/*&au_kset->kobj*/,
				   SysaufsSb_PREFIX "%lx",
				   au_si_mask ^ (unsigned long)sbinfo);
	AuTraceErr(err);
	return err;
}
コード例 #15
0
ファイル: sysfs.c プロジェクト: miettal/armadillo420_standard
int gdlm_kobject_setup(struct gdlm_ls *ls, struct kobject *fskobj)
{
	int error;

	ls->kobj.kset = gdlm_kset;
	error = kobject_init_and_add(&ls->kobj, &gdlm_ktype, fskobj,
				     "lock_module");
	if (error)
		log_error("can't register kobj %d", error);
	kobject_uevent(&ls->kobj, KOBJ_ADD);

	return error;
}
コード例 #16
0
ファイル: snapfs-mgmt.c プロジェクト: nvmd/snapfs
int setup_snapfs_mount_point_mgmt(struct dentry *dentry)
{
	int result;
	int next_snapfs_mnt_point_number;
	const int mnt_point_name_length = 30;
	struct snapfs_mnt_point *mnt_point;
	
	next_snapfs_mnt_point_number = snapfs_mnt_point_number + 1;
	mnt_point = &snapfs_mnt_points[next_snapfs_mnt_point_number];

	mnt_point->name = kmalloc(mnt_point_name_length, GFP_KERNEL);
	if (!mnt_point->name) {
		printk(KERN_ERR "Can't do kmalloc\n");
		return -ENOMEM;
	}
	snprintf(mnt_point->name, mnt_point_name_length, 
			"mnt_point_%d", next_snapfs_mnt_point_number);
	snapfs_mntpoint_ktype.sysfs_ops = snapfs_kobj->ktype->sysfs_ops;
	result = kobject_init_and_add(&mnt_point->kobj, &snapfs_mntpoint_ktype, 
					snapfs_kobj, mnt_point->name);
	if (result) {
		printk(KERN_ERR "Can't init SnapFS mount point KObject\n");
		kobject_put(&mnt_point->kobj);
		return -ENOMEM;
	}
	
	mnt_point->attrs = kmalloc(sizeof(*(mnt_point->attrs)), GFP_KERNEL);
	if (!mnt_point->attrs) {
		printk(KERN_ERR "Can't do kmalloc\n");
		kfree(mnt_point->name);
		kobject_put(&mnt_point->kobj);
		return -ENOMEM;
	}
	memset(mnt_point->attrs, 0, sizeof(*mnt_point->attrs));
	
	mnt_point->attrs->attrs = snapfs_mnt_attrs;
	mnt_point->dentry = dentry;
	
	result = sysfs_create_group(&mnt_point->kobj, mnt_point->attrs);
	if (result) {
		printk(KERN_ERR "Can't create sysfs group");
		kfree(mnt_point->name);
		kobject_put(&mnt_point->kobj);
		kfree(mnt_point->attrs);
		return result;
	}

	snapfs_mnt_point_number = next_snapfs_mnt_point_number;
	return result;
}
コード例 #17
0
/**
 * efivar_create_sysfs_entry - create a new entry in sysfs
 * @new_var: efivar entry to create
 *
 * Returns 0 on success, negative error code on failure
 */
static int
efivar_create_sysfs_entry(struct efivar_entry *new_var)
{
	int i, short_name_size;
	char *short_name;
	unsigned long variable_name_size;
	efi_char16_t *variable_name;
	int ret;

	variable_name = new_var->var.VariableName;
	variable_name_size = ucs2_strlen(variable_name) * sizeof(efi_char16_t);

	/*
	 * Length of the variable bytes in ASCII, plus the '-' separator,
	 * plus the GUID, plus trailing NUL
	 */
	short_name_size = variable_name_size / sizeof(efi_char16_t)
				+ 1 + EFI_VARIABLE_GUID_LEN + 1;

	short_name = kzalloc(short_name_size, GFP_KERNEL);

	if (!short_name)
		return -ENOMEM;

	/* Convert Unicode to normal chars (assume top bits are 0),
	   ala UTF-8 */
	for (i=0; i < (int)(variable_name_size / sizeof(efi_char16_t)); i++) {
		short_name[i] = variable_name[i] & 0xFF;
	}
	/* This is ugly, but necessary to separate one vendor's
	   private variables from another's.         */

	*(short_name + strlen(short_name)) = '-';
	efi_guid_to_str(&new_var->var.VendorGuid,
			 short_name + strlen(short_name));

	new_var->kobj.kset = efivars_kset;

	ret = kobject_init_and_add(&new_var->kobj, &efivar_ktype,
				   NULL, "%s", short_name);
	kfree(short_name);
	if (ret)
		return ret;

	kobject_uevent(&new_var->kobj, KOBJ_ADD);
	efivar_entry_add(new_var, &efivar_sysfs_list);

	return 0;
}
コード例 #18
0
int ccci_sysfs_add_modem(struct ccci_modem *md)
{
	int ret;
	
	if(!ccci_sys_info)
		return -CCCI_ERR_SYSFS_NOT_READY;

	memset(&md->kobj, 0, sizeof(struct kobject));
	ret = kobject_init_and_add(&md->kobj, &ccci_md_ktype, &ccci_sys_info->kobj, "MDSYS%d", md->index+1);
	if (ret < 0) {
		kobject_put(&md->kobj);
        CCCI_ERR_MSG(md->index, SYSFS, "fail to add md kobject\n");
    }
	return ret;
}
コード例 #19
0
ファイル: mem.c プロジェクト: kewinrausch/RNS
int mem_rns_init() {
	int status = SUCCESS;

#ifdef RNS_SYSFS
	status = kobject_init_and_add(
		&mem_kobj, &mem_sys_ktype, &core_kobj, "memory");

	if(status) {
		LOG_ERR("Memory sysfs failure, status=%d", status);
		return ERR_MEM_INIT_SYSFS;
	}
#endif

	return status;
}
コード例 #20
0
int gb_audio_manager_module_create(
	struct gb_audio_manager_module **module,
	struct kset *manager_kset,
	int id, struct gb_audio_manager_module_descriptor *desc)
{
	int err;
	struct gb_audio_manager_module *m;

	m = kzalloc(sizeof(*m), GFP_ATOMIC);
	if (!m)
		return -ENOMEM;

	/* Initialize the node */
	INIT_LIST_HEAD(&m->list);

	/* Set the module id */
	m->id = id;

	/* Copy the provided descriptor */
	memcpy(&m->desc, desc, sizeof(*desc));

	/* set the kset */
	m->kobj.kset = manager_kset;

	/*
	 * Initialize and add the kobject to the kernel.  All the default files
	 * will be created here.  As we have already specified a kset for this
	 * kobject, we don't have to set a parent for the kobject, the kobject
	 * will be placed beneath that kset automatically.
	 */
	err = kobject_init_and_add(&m->kobj, &gb_audio_module_type, NULL, "%d",
				   id);
	if (err) {
		pr_err("failed initializing kobject for audio module #%d\n",
		       id);
		kobject_put(&m->kobj);
		return err;
	}

	/*
	 * Notify the object was created
	 */
	send_add_uevent(m);

	*module = m;
	pr_info("Created audio module #%d\n", id);
	return 0;
}
コード例 #21
0
ファイル: ttm_bo.c プロジェクト: ARMP/android_kernel_lge_x3
int ttm_bo_global_init(struct drm_global_reference *ref)
{
	struct ttm_bo_global_ref *bo_ref =
		container_of(ref, struct ttm_bo_global_ref, ref);
	struct ttm_bo_global *glob = ref->object;
	int ret;

	mutex_init(&glob->device_list_mutex);
	spin_lock_init(&glob->lru_lock);
	glob->mem_glob = bo_ref->mem_glob;
	glob->dummy_read_page = alloc_page(__GFP_ZERO | GFP_DMA32);

	if (unlikely(glob->dummy_read_page == NULL)) {
		ret = -ENOMEM;
		goto out_no_drp;
	}

	INIT_LIST_HEAD(&glob->swap_lru);
	INIT_LIST_HEAD(&glob->device_list);

	ttm_mem_init_shrink(&glob->shrink, ttm_bo_swapout);
	ret = ttm_mem_register_shrink(glob->mem_glob, &glob->shrink);
	if (unlikely(ret != 0)) {
		printk(KERN_ERR TTM_PFX
		       "Could not register buffer object swapout.\n");
		goto out_no_shrink;
	}

	glob->ttm_bo_extra_size =
		ttm_round_pot(sizeof(struct ttm_tt)) +
		ttm_round_pot(sizeof(struct ttm_backend));

	glob->ttm_bo_size = glob->ttm_bo_extra_size +
		ttm_round_pot(sizeof(struct ttm_buffer_object));

	atomic_set(&glob->bo_count, 0);

	ret = kobject_init_and_add(
		&glob->kobj, &ttm_bo_glob_kobj_type, ttm_get_kobj(), "buffer_objects");
	if (unlikely(ret != 0))
		kobject_put(&glob->kobj);
	return ret;
out_no_shrink:
	__free_page(glob->dummy_read_page);
out_no_drp:
	kfree(glob);
	return ret;
}
コード例 #22
0
ファイル: f_acm.c プロジェクト: tinocyngn/sofia-kernel
static struct usb_function *acm_alloc_func(struct usb_function_instance *fi)
{
	struct f_serial_opts *opts;
	struct f_acm *acm;
	int ret;

	acm = kzalloc(sizeof(*acm), GFP_KERNEL);
	if (!acm)
		return ERR_PTR(-ENOMEM);

	spin_lock_init(&acm->lock);

	acm->port.connect = acm_connect;
	acm->port.disconnect = acm_disconnect;
	acm->port.send_break = acm_send_break;

	acm->port.func.name = "acm";
	acm->port.func.strings = acm_strings;
	/* descriptors are per-instance copies */
	acm->port.func.bind = acm_bind;
	acm->port.func.set_alt = acm_set_alt;
	acm->port.func.setup = acm_setup;
	acm->port.func.disable = acm_disable;

	opts = container_of(fi, struct f_serial_opts, func_inst);
	acm->port_num = opts->port_num;
	acm->port.func.unbind = acm_unbind;
	acm->port.func.free_func = acm_free_func;

	/* Initialize sysfs defaults */
	strcpy(acm->ctrl_string_buf, "CDC Abstract Control Model (ACM)");
	strcpy(acm->data_string_buf, "CDC ACM Data");
	strcpy(acm->iad_string_buf, "CDC Serial");
	acm->iad_proto = USB_CDC_ACM_PROTO_AT_V25TER;
	acm->ctrl_intf_proto = USB_CDC_ACM_PROTO_AT_V25TER;

	WARN_ON_ONCE(!fi->fd->parent);
	ret = kobject_init_and_add(&acm->kobj, &acm_type, fi->fd->parent,
						"%s%d", "port", acm->port_num);
	if (ret) {
		pr_err("%s: Failed to add kobject\n", __func__);
		kobject_put(&acm->kobj);
		kfree(acm);
		return ERR_PTR(-EINVAL);
	}

	return &acm->port.func;
}
コード例 #23
0
ファイル: sysfs.c プロジェクト: 12rafael/jellytimekernel
int btrfs_sysfs_add_root(struct btrfs_root *root)
{
	int error;

	error = kobject_init_and_add(&root->root_kobj, &btrfs_root_ktype,
				     &root->fs_info->super_kobj,
				     "%s", root->name);
	if (error)
		goto fail;

	return 0;

fail:
	printk(KERN_ERR "btrfs: sysfs creation for root failed\n");
	return error;
}
コード例 #24
0
static int htc_simhotswap_probe(struct platform_device *pdev)
{
	int ret = 0;
	printk(KERN_INFO"delay work version %s\n",__func__);

	mutex_init(&htc_hotswap_info.lock);

	//INIT_WORK(&htc_hotswap_info.hotswap_work, hotswap_work_func);
	INIT_DELAYED_WORK(&htc_hotswap_info.hotswap_work, hotswap_work_func);
	htc_hotswap_info.hotswap_wq = create_singlethread_workqueue("htc_simhotswap");

	ret = misc_register(&sim_hotswap_misc);
	if (ret) {
		pr_err("failed to register misc device!\n");
		goto fail;
	}

	htc_hotswap_kset = kset_create_and_add("event", NULL,
			kobject_get(&sim_hotswap_misc.this_device->kobj));
	if (!htc_hotswap_kset) {
		ret = -ENOMEM;
		goto fail;
	}

	htc_hotswap_info.simhotswap_kobj.kset = htc_hotswap_kset;

	ret = kobject_init_and_add(&htc_hotswap_info.simhotswap_kobj,
			&htc_hotswap_ktype, NULL, "simhotswap");
	if (ret) {
		kobject_put(&htc_hotswap_info.simhotswap_kobj);
		goto fail;
	}	
	oldStatus = gpio_get_value(SIM_DETECT);
	pr_info("htc_simhotswap_probe(): finish SIM init status=%d\n",oldStatus);

	ret = request_irq(gpio_to_irq(SIM_DETECT),
			sim_detect_irq,
			IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
			"sim_detect", NULL);
	if (ret) {
		pr_err("%s:Failed to request irq, ret=%d\n", __func__, ret);
	}

fail:

	return ret;
}
コード例 #25
0
ファイル: kobject.c プロジェクト: njitdkj082yy/linux-kernel
static int kobj_test_init()
{
	printk("kobj test init\n");
	printk("kobj->state_initialized=%d\n",kobj.state_initialized);
	printk("kobj->state_in_sysfs=%d\n",kobj.state_add_uevent_sent);
	printk("kobj->state_add_uevent_sent=%d\n",kobj.state_remove_uevent_sent);
	printk("kobj->uevent_suppress=%d\n",kobj.uevent_suppress);
	printk("kobj->name = %s\n",kobj.name);
	kobject_init_and_add(&kobj,&ktype,NULL,"kobject_test");
	printk("\n\n*******************************\n\n");
	printk("kobj->state_initialized=%d\n",kobj.state_initialized);
	printk("kobj->state_in_sysfs=%d\n",kobj.state_add_uevent_sent);
	printk("kobj->state_add_uevent_sent=%d\n",kobj.state_remove_uevent_sent);
	printk("kobj->uevent_suppress=%d\n",kobj.uevent_suppress);
	printk("kobj->name = %s\n",kobj.name);
	return 0;
}
コード例 #26
0
ファイル: hdm_usb.c プロジェクト: acton393/linux
/**
 * create_most_dci_obj - allocates a dci object
 * @parent: parent kobject
 *
 * This creates a dci object and registers it with sysfs.
 * Returns a pointer to the object or NULL when something went wrong.
 */
static struct
most_dci_obj *create_most_dci_obj(struct kobject *parent)
{
	struct most_dci_obj *most_dci = kzalloc(sizeof(*most_dci), GFP_KERNEL);
	int retval;

	if (!most_dci)
		return NULL;

	retval = kobject_init_and_add(&most_dci->kobj, &most_dci_ktype, parent,
				      "dci");
	if (retval) {
		kobject_put(&most_dci->kobj);
		return NULL;
	}
	return most_dci;
}
コード例 #27
0
static int __init boot_mod_init(void)
{
    int ret;

    /* allocate device major number */
    if (alloc_chrdev_region(&boot_dev_num, 0, 1, BOOT_DEV_NAME) < 0) {
        printk("[%s] fail to register chrdev\n",MOD);
        return -1;
    }

    /* add character driver */
    cdev_init(&boot_cdev, &boot_fops);
    ret = cdev_add(&boot_cdev, boot_dev_num, 1);
    if (ret < 0) {
        printk("[%s] fail to add cdev\n",MOD);
        return ret;
    }

	/* create class (device model) */
    boot_class = class_create(THIS_MODULE, BOOT_DEV_NAME);
    if (IS_ERR(boot_class)) {
        printk("[%s] fail to create class\n",MOD);
        return (int)boot_class;
    }

    boot_device = device_create(boot_class, NULL, boot_dev_num, NULL, BOOT_DEV_NAME);
    if (IS_ERR(boot_device)) {
        printk("[%s] fail to create device\n",MOD);
        return (int)boot_device;
    }

    /* add kobject */
    ret = kobject_init_and_add(&boot_kobj, &boot_ktype, &(boot_device->kobj), BOOT_SYSFS);
    if (ret < 0) {
        printk("[%s] fail to add kobject\n",MOD);
        return ret;
    }

    printk("[%s] chip hw code = 0x%x\n",MOD,get_chip_code());
    printk("[%s] chip eco version = 0x%x\n",MOD,get_chip_eco_ver());

    /* create proc entry at /proc/boot_mode */
    create_proc_read_entry("boot_mode", S_IRUGO, NULL, boot_mode_proc, NULL);

    return 0;
}
コード例 #28
0
ファイル: sysaufs.c プロジェクト: GREYFOXRGR/BPI-M3-bsp
int sysaufs_si_init(struct au_sbinfo *sbinfo)
{
	int err;

	sbinfo->si_kobj.kset = sysaufs_kset;
	/* cf. sysaufs_name() */
	err = kobject_init_and_add
		(&sbinfo->si_kobj, &au_sbi_ktype, /*&sysaufs_kset->kobj*/NULL,
		 SysaufsSiNamePrefix "%lx", sysaufs_si_id(sbinfo));

	dbgaufs_si_null(sbinfo);
	if (!err) {
		err = dbgaufs_si_init(sbinfo);
		if (unlikely(err))
			kobject_put(&sbinfo->si_kobj);
	}
	return err;
}
コード例 #29
0
ファイル: sysfs.c プロジェクト: mkrufky/linux
int __init f2fs_init_sysfs(void)
{
	int ret;

	kobject_set_name(&f2fs_kset.kobj, "f2fs");
	f2fs_kset.kobj.parent = fs_kobj;
	ret = kset_register(&f2fs_kset);
	if (ret)
		return ret;

	ret = kobject_init_and_add(&f2fs_feat, &f2fs_feat_ktype,
				   NULL, "features");
	if (ret)
		kset_unregister(&f2fs_kset);
	else
		f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
	return ret;
}
コード例 #30
0
int kgsl_device_snapshot_init(struct kgsl_device *device)
{
	int ret;
	struct platform_device *pdev =
		container_of(device->parentdev, struct platform_device, dev);
	struct kgsl_device_platform_data *pdata = pdev->dev.platform_data;

	if (device->snapshot == NULL) {
		if(pdata->snapshot_address) {
			device->snapshot = ioremap(pdata->snapshot_address, KGSL_SNAPSHOT_MEMSIZE);
			PR_DISP_INFO("snapshot created at va %p pa %x\n",
				device->snapshot, pdata->snapshot_address);
		} else
			device->snapshot = kzalloc(KGSL_SNAPSHOT_MEMSIZE, GFP_KERNEL);
	}

	if (device->snapshot == NULL)
		return -ENOMEM;

	device->snapshot_maxsize = KGSL_SNAPSHOT_MEMSIZE;
	device->snapshot_timestamp = 0;

	ret = kobject_init_and_add(&device->snapshot_kobj, &ktype_snapshot,
		&device->dev->kobj, "snapshot");
	if (ret)
		goto done;

	ret = sysfs_create_bin_file(&device->snapshot_kobj, &snapshot_attr);
	if (ret)
		goto done;

	ret  = sysfs_create_file(&device->snapshot_kobj, &attr_trigger.attr);
	if (ret)
		goto done;

	ret  = sysfs_create_file(&device->snapshot_kobj, &attr_timestamp.attr);
	if (ret)
		goto done;

	ret  = sysfs_create_file(&device->snapshot_kobj, &attr_no_panic.attr);

done:
	return ret;
}