/** * cmm_sysfs_register - Register with sysfs * * Return value: * 0 on success / other on failure **/ static int cmm_sysfs_register(struct sys_device *sysdev) { int i, rc; if ((rc = sysdev_class_register(&cmm_sysdev_class))) return rc; sysdev->id = 0; sysdev->cls = &cmm_sysdev_class; if ((rc = sysdev_register(sysdev))) goto class_unregister; for (i = 0; i < ARRAY_SIZE(cmm_attrs); i++) { if ((rc = sysdev_create_file(sysdev, cmm_attrs[i]))) goto fail; } return 0; fail: while (--i >= 0) sysdev_remove_file(sysdev, cmm_attrs[i]); sysdev_unregister(sysdev); class_unregister: sysdev_class_unregister(&cmm_sysdev_class); return rc; }
static void bq27541_battery_sysdev_ctrl_exit(void) { sysdev_remove_file(&bq27541_battery_device, &attr_battery_id); sysdev_remove_file(&bq27541_battery_device, &attr_battery_current); sysdev_remove_file(&bq27541_battery_device, &attr_battery_voltage); sysdev_remove_file(&bq27541_battery_device, &attr_battery_temperature); sysdev_remove_file(&bq27541_battery_device, &attr_battery_capacity); sysdev_remove_file(&bq27541_battery_device, &attr_battery_mAH); sysdev_remove_file(&bq27541_battery_device, &attr_battery_voltage_thresholds); sysdev_remove_file(&bq27541_battery_device, &attr_battery_polling_intervals); sysdev_remove_file(&bq27541_battery_device, &attr_battery_temp_thresholds); sysdev_remove_file(&bq27541_battery_device, &attr_battery_i2c_address); sysdev_remove_file(&bq27541_battery_device, &attr_battery_error); sysdev_remove_file(&bq27541_battery_device, &attr_battery_suspend_current); sysdev_remove_file(&bq27541_battery_device, &attr_battery_current_diags); sysdev_remove_file(&bq27541_battery_device, &attr_battery_suspend_current_diags); sysdev_remove_file(&bq27541_battery_device, &attr_battery_cycl); sysdev_remove_file(&bq27541_battery_device, &attr_battery_lmd); sysdev_remove_file(&bq27541_battery_device, &attr_battery_cyct); sysdev_remove_file(&bq27541_battery_device, &attr_resume_stats); sysdev_remove_file(&bq27541_battery_device, &attr_battreg); sysdev_remove_file(&bq27541_battery_device, &attr_battreg_value); sysdev_unregister(&bq27541_battery_device); sysdev_class_unregister(&bq27541_battery_sysclass); }
static void dvfs_sysdev_ctrl_exit(void) { sysdev_remove_file(&dvfs_device, &attr_enable); sysdev_remove_file(&dvfs_device, &attr_status); sysdev_unregister(&dvfs_device); sysdev_class_unregister(&dvfs_sysclass); }
/** * cmm_unregister_sysfs - Unregister from sysfs * **/ static void cmm_unregister_sysfs(struct sys_device *sysdev) { int i; for (i = 0; i < ARRAY_SIZE(cmm_attrs); i++) sysdev_remove_file(sysdev, cmm_attrs[i]); sysdev_unregister(sysdev); sysdev_class_unregister(&cmm_sysdev_class); }
/** * unregister_node - unregister a node device * @node: node going away * * Unregisters a node device @node. All the devices on the node must be * unregistered before calling this function. */ void unregister_node(struct node *node) { sysdev_remove_file(&node->sysdev, &attr_cpumap); sysdev_remove_file(&node->sysdev, &attr_meminfo); sysdev_remove_file(&node->sysdev, &attr_numastat); sysdev_remove_file(&node->sysdev, &attr_distance); sysdev_unregister(&node->sysdev); }
static void unregister_memory(struct memory_block *memory) { BUG_ON(memory->sysdev.cls != &memory_sysdev_class); /* drop the ref. we got in remove_memory_block() */ kobject_put(&memory->sysdev.kobj); sysdev_unregister(&memory->sysdev); }
static __exit void unregister_balloon(struct sys_device *sysdev) { int i; sysfs_remove_group(&sysdev->kobj, &balloon_info_group); for (i = 0; i < ARRAY_SIZE(balloon_attrs); i++) sysdev_remove_file(sysdev, balloon_attrs[i]); sysdev_unregister(sysdev); sysdev_class_unregister(&balloon_sysdev_class); }
static void bootstrap_exit(void) { kfree(save_buffer); sysdev_driver_unregister(&mioa701_sysclass, &driver_bootstrap); sysdev_unregister(&sysdev_bootstrap); sysdev_class_unregister(&mioa701_sysclass); printk(KERN_CRIT "Unregistering mioa701 suspend will hang next" "resume !!!\n"); }
void unregister_cpu(struct cpu *cpu) { int logical_cpu = cpu->sysdev.id; unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu)); sysdev_remove_file(&cpu->sysdev, &attr_online); sysdev_unregister(&cpu->sysdev); per_cpu(cpu_sys_devices, logical_cpu) = NULL; return; }
void unregister_cpu(struct cpu *cpu, struct node *root) { if (root) sysfs_remove_link(&root->sysdev.kobj, kobject_name(&cpu->sysdev.kobj)); sysdev_remove_file(&cpu->sysdev, &attr_online); sysdev_unregister(&cpu->sysdev); return; }
static void unregister_memory(struct memory_block *memory, struct mem_section *section, struct node *root) { BUG_ON(memory->sysdev.cls != &memory_sysdev_class); BUG_ON(memory->sysdev.id != __section_nr(section)); sysdev_unregister(&memory->sysdev); if (root) sysfs_remove_link(&root->sysdev.kobj, kobject_name(&memory->sysdev.kobj)); }
void unregister_cpu(struct cpu *cpu, struct node *root) { int logical_cpu = cpu->sysdev.id; if (root) sysfs_remove_link(&root->sysdev.kobj, kobject_name(&cpu->sysdev.kobj)); sysdev_remove_file(&cpu->sysdev, &attr_online); sysdev_unregister(&cpu->sysdev); cpu_sys_devices[logical_cpu] = NULL; return; }
/** * unregister_node - unregister a node device * @node: node going away * * Unregisters a node device @node. All the devices on the node must be * unregistered before calling this function. */ void unregister_node(struct node *node) { sysdev_remove_file(&node->sysdev, &attr_cpumap); sysdev_remove_file(&node->sysdev, &attr_cpulist); sysdev_remove_file(&node->sysdev, &attr_meminfo); sysdev_remove_file(&node->sysdev, &attr_numastat); sysdev_remove_file(&node->sysdev, &attr_distance); scan_unevictable_unregister_node(node); hugetlb_unregister_node(node); /* no-op, if memoryless node */ sysdev_unregister(&node->sysdev); }
void dma_remove_sysfs_files(struct dma_channel *chan, struct dma_info *info) { struct sys_device *dev = &chan->dev; char name[16]; sysdev_remove_file(dev, &attr_dev_id); sysdev_remove_file(dev, &attr_count); sysdev_remove_file(dev, &attr_mode); sysdev_remove_file(dev, &attr_flags); sysdev_remove_file(dev, &attr_config); snprintf(name, sizeof(name), "dma%d", chan->chan); sysfs_remove_link(&info->pdev->dev.kobj, name); sysdev_unregister(dev); }
/* * Sys device register * * sysdev file: * * /sys/devices/system/zte_ftm/zte_ftm0/fusion * /sys/devices/system/zte_ftm/zte_ftm0/simlocking */ static int32_t ftm_register_sysdev(struct sys_device *sysdev) { int32_t ret; int32_t i; ret = sysdev_class_register(&ftm_sysdev_class); if (ret) { return ret; } sysdev->id = 0; sysdev->cls = &ftm_sysdev_class; ret = sysdev_register(sysdev); if (ret) { sysdev_class_unregister(&ftm_sysdev_class); return ret; } for (i = 0; i < ARRAY_SIZE(ftm_attrs); i++) { ret = sysdev_create_file(sysdev, ftm_attrs[i]); if (ret) { goto ftm_fail; } } return 0; ftm_fail: while (--i >= 0) sysdev_remove_file(sysdev, ftm_attrs[i]); sysdev_unregister(sysdev); sysdev_class_unregister(&ftm_sysdev_class); return ret; }
/* * MSM LED Trigger Sys Device Register * * 1. Torch Mode * enable: $ echo "1" > /sys/devices/system/led-flash/led-flash0/torch * disable: $ echo "0" > /sys/devices/system/led-flash/led-flash0/torch * * 2. Flash Mode * enable: $ echo "1" > /sys/devices/system/led-flash/led-flash0/flash * disable: $ echo "0" > /sys/devices/system/led-flash/led-flash0/flash */ static int32_t msm_led_trigger_register_sysdev(struct msm_led_flash_ctrl_t *fctrl) { int32_t i, rc; rc = sysdev_class_register(&msm_led_trigger_sysdev_class); if (rc) { return rc; } msm_led_trigger_sysdev.id = 0; msm_led_trigger_sysdev.cls = &msm_led_trigger_sysdev_class; rc = sysdev_register(&msm_led_trigger_sysdev); if (rc) { sysdev_class_unregister(&msm_led_trigger_sysdev_class); return rc; } for (i = 0; i < ARRAY_SIZE(msm_led_trigger_sysdev_attrs); ++i) { rc = sysdev_create_file(&msm_led_trigger_sysdev, msm_led_trigger_sysdev_attrs[i]); if (rc) { goto msm_led_trigger_register_sysdev_failed; } } msm_led_trigger_sysdev_fctrl = fctrl; return 0; msm_led_trigger_register_sysdev_failed: while (--i >= 0) sysdev_remove_file(&msm_led_trigger_sysdev, msm_led_trigger_sysdev_attrs[i]); sysdev_unregister(&msm_led_trigger_sysdev); sysdev_class_unregister(&msm_led_trigger_sysdev_class); return rc; }
static int __init register_balloon(struct sys_device *sysdev) { int i, error; error = sysdev_class_register(&balloon_sysdev_class); if (error) return error; sysdev->id = 0; sysdev->cls = &balloon_sysdev_class; error = sysdev_register(sysdev); if (error) { sysdev_class_unregister(&balloon_sysdev_class); return error; } for (i = 0; i < ARRAY_SIZE(balloon_attrs); i++) { error = sysdev_create_file(sysdev, balloon_attrs[i]); if (error) goto fail; } error = sysfs_create_group(&sysdev->kobj, &balloon_info_group); if (error) goto fail; return 0; fail: while (--i >= 0) sysdev_remove_file(sysdev, balloon_attrs[i]); sysdev_unregister(sysdev); sysdev_class_unregister(&balloon_sysdev_class); return error; }
static void __exit msm_show_resume_irq_exit(void) { sysdev_unregister(&msm_show_resume_irq_device); sysdev_class_unregister(&msm_show_resume_irq_sysclass); }
static int __devexit mxs_lradc_remove(struct platform_device *pdev) { sysdev_unregister(&mxs_lradc.sys); return 0; }
static int imapx200_dma_init_xxx(int chno, int dma_ch, int irq, unsigned int base) { struct imapx200_dma_chan *chptr = &imapx200_chans[chno]; struct imapx200_dmac *dmac; char clkname[16]; void __iomem *regs; void __iomem *regptr; int err, ch; dmac = kzalloc(sizeof(struct imapx200_dmac), GFP_KERNEL); if (!dmac) { printk(KERN_ERR "%s: failed to alloc mem\n", __func__); return -ENOMEM; } dmac->sysdev.id = chno / 8; dmac->sysdev.cls = &dma_sysclass; err = sysdev_register(&dmac->sysdev); if (err) { printk(KERN_ERR "%s: failed to register sysdevice\n", __func__); goto err_alloc; } regs = ioremap(base, DW_REGLEN); if (!regs) { printk(KERN_ERR "%s: failed to ioremap()\n", __func__); err = -ENXIO; goto err_dev; } snprintf(clkname, sizeof(clkname), "dma%d", dmac->sysdev.id); /* dmac->clk = clk_get(NULL, clkname); if (IS_ERR(dmac->clk)) { printk(KERN_ERR "%s: failed to get clock %s\n", __func__, clkname); err = PTR_ERR(dmac->clk); goto err_map; } clk_enable(dmac->clk); */ dmac->regs = regs; dmac->dma_ch = dma_ch; dmac->channels = chptr; err = request_irq(irq, imapx200_dma_irq, 0, "DMA", dmac); if (err < 0) { printk(KERN_ERR "%s: failed to get irq\n", __func__); goto err_clk; } regptr = regs + (0); for (ch = 0; ch < 8; ch++, chno++, chptr++) { printk(KERN_INFO "%s: registering DMA %d (%p)\n", __func__, chno, regptr); chptr->bit = 1 << ch; chptr->number = chno; chptr->regs = regptr; regptr += DW_CH_STRIDE; dma_clear_bit(dmac,CH_EN,chptr->bit); } /* for the moment, permanently enable the controller */ dma_writel(dmac, CFG, DW_CFG_DMA_EN); printk(KERN_INFO "DW: IRQ %d, at %p\n", irq, regs); return 0; err_clk: clk_disable(dmac->clk); clk_put(dmac->clk); err_map: iounmap(regs); err_dev: sysdev_unregister(&dmac->sysdev); err_alloc: kfree(dmac); return err; }
static void mx50_accessory_sysdev_ctrl_exit(void) { sysdev_remove_file(&mx50_accessory_device, &attr_mx50_accessory_state); sysdev_unregister(&mx50_accessory_device); sysdev_class_unregister(&mx50_accessory_sysclass); }
static int __init s3c64xx_dma_probe(struct platform_device *pdev) { struct s3c2410_dma_chan *chptr = &s3c2410_chans[8*pdev->id]; struct s3c64xx_dmac *dmac; char clkname[16]; void __iomem *regs; void __iomem *regptr; int err, ch, irq; struct resource *res_mem, *res_chbase; dmac = kzalloc(sizeof(struct s3c64xx_dmac), GFP_KERNEL); if (!dmac) { printk(KERN_ERR "%s: failed to alloc mem\n", __func__); return -ENOMEM; } res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); res_chbase = platform_get_resource(pdev, IORESOURCE_DMA, 0); dmac->sysdev.id = pdev->id; dmac->sysdev.cls = &dma_sysclass; err = sysdev_register(&dmac->sysdev); if (err) { printk(KERN_ERR "%s: failed to register sysdevice\n", __func__); goto err_alloc; } regs = ioremap(res_mem->start, resource_size(res_mem)); if (!regs) { printk(KERN_ERR "%s: failed to ioremap()\n", __func__); err = -ENXIO; goto err_dev; } snprintf(clkname, sizeof(clkname), "dma%d", dmac->sysdev.id); dmac->clk = clk_get(&pdev->dev, clkname); if (IS_ERR(dmac->clk)) { printk(KERN_ERR "%s: failed to get clock %s\n", __func__, clkname); err = PTR_ERR(dmac->clk); goto err_map; } clk_enable(dmac->clk); dmac->regs = regs; dmac->chanbase = res_chbase->start; dmac->channels = chptr; dmac->dev = &pdev->dev; irq = platform_get_irq(pdev, 0); err = request_irq(irq, s3c64xx_dma_irq, 0, "DMA", dmac); if (err < 0) { printk(KERN_ERR "%s: failed to get irq\n", __func__); goto err_clk; } regptr = regs + PL080_Cx_BASE(0); for (ch = 0; ch < 8; ch++, chptr++) { pr_debug("%s: registering DMA %d (%p)\n", __func__, 8*pdev->id + ch, regptr); chptr->bit = 1 << ch; chptr->number = 8*pdev->id + ch; chptr->dmac = dmac; chptr->regs = regptr; atomic_set(&chptr->started, 0); regptr += PL080_Cx_STRIDE; } platform_set_drvdata(pdev, dmac); /* for the moment, permanently enable the controller */ writel(PL080_CONFIG_ENABLE, regs + PL080_CONFIG); printk(KERN_INFO "PL080: IRQ %d, at %p, channels %d..%d\n", irq, regs, 8*pdev->id, 8*pdev->id+8); return 0; err_clk: clk_disable(dmac->clk); clk_put(dmac->clk); err_map: iounmap(regs); err_dev: sysdev_unregister(&dmac->sysdev); err_alloc: kfree(dmac); return err; }
static int s3c64xx_dma_init1(int chno, enum dma_ch chbase, int irq, unsigned int base) { struct s3c2410_dma_chan *chptr = &s3c2410_chans[chno]; struct s3c64xx_dmac *dmac; char clkname[16]; void __iomem *regs; void __iomem *regptr; int err, ch; dmac = kzalloc(sizeof(struct s3c64xx_dmac), GFP_KERNEL); if (!dmac) { printk(KERN_ERR "%s: failed to alloc mem\n", __func__); return -ENOMEM; } dmac->sysdev.id = chno / 8; dmac->sysdev.cls = &dma_sysclass; err = sysdev_register(&dmac->sysdev); if (err) { printk(KERN_ERR "%s: failed to register sysdevice\n", __func__); goto err_alloc; } regs = ioremap(base, 0x200); if (!regs) { printk(KERN_ERR "%s: failed to ioremap()\n", __func__); err = -ENXIO; goto err_dev; } snprintf(clkname, sizeof(clkname), "dma%d", dmac->sysdev.id); dmac->clk = clk_get(NULL, clkname); if (IS_ERR(dmac->clk)) { printk(KERN_ERR "%s: failed to get clock %s\n", __func__, clkname); err = PTR_ERR(dmac->clk); goto err_map; } clk_enable(dmac->clk); dmac->regs = regs; dmac->chanbase = chbase; dmac->channels = chptr; err = request_irq(irq, s3c64xx_dma_irq, 0, "DMA", dmac); if (err < 0) { printk(KERN_ERR "%s: failed to get irq\n", __func__); goto err_clk; } regptr = regs + PL080_Cx_BASE(0); for (ch = 0; ch < 8; ch++, chno++, chptr++) { printk(KERN_INFO "%s: registering DMA %d (%p)\n", __func__, chno, regptr); chptr->bit = 1 << ch; chptr->number = chno; chptr->dmac = dmac; chptr->regs = regptr; regptr += PL008_Cx_STRIDE; } /* for the moment, permanently enable the controller */ writel(PL080_CONFIG_ENABLE, regs + PL080_CONFIG); printk(KERN_INFO "PL080: IRQ %d, at %p\n", irq, regs); return 0; err_clk: clk_disable(dmac->clk); clk_put(dmac->clk); err_map: iounmap(regs); err_dev: sysdev_unregister(&dmac->sysdev); err_alloc: kfree(dmac); return err; }
static void exit_sysfs(void) { sysdev_unregister(&device_oprofile); sysdev_class_unregister(&oprofile_sysclass); }
/* * First routine called when the kernel module is loaded */ static int __init tf_device_register(void) { int error; struct tf_device *dev = &g_tf_dev; dprintk(KERN_INFO "tf_device_register()\n"); /* * Initialize the device */ dev->dev_number = MKDEV(device_major_number, TF_DEVICE_MINOR_NUMBER); cdev_init(&dev->cdev, &g_tf_device_file_ops); dev->cdev.owner = THIS_MODULE; g_tf_sysdev.id = 0; g_tf_sysdev.cls = &g_tf_device_sys_class; INIT_LIST_HEAD(&dev->connection_list); spin_lock_init(&dev->connection_list_lock); #if defined(MODULE) && defined(CONFIG_TF_ZEBRA) error = (*tf_comm_early_init)(); if (error) goto module_early_init_failed; error = tf_device_mshield_init(smc_mem); if (error) goto mshield_init_failed; #ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS error = tf_crypto_hmac_module_init(); if (error) goto hmac_init_failed; error = tf_self_test_register_device(); if (error) goto self_test_register_device_failed; #endif #endif /* register the sysfs object driver stats */ error = kobject_init_and_add(&dev->kobj, &tf_ktype, NULL, "%s", TF_DEVICE_BASE_NAME); if (error) { printk(KERN_ERR "tf_device_register(): " "kobject_init_and_add failed (error %d)!\n", error); kobject_put(&dev->kobj); goto kobject_init_and_add_failed; } /* * Register the system device. */ error = sysdev_class_register(&g_tf_device_sys_class); if (error != 0) { printk(KERN_ERR "tf_device_register():" " sysdev_class_register failed (error %d)!\n", error); goto sysdev_class_register_failed; } error = sysdev_register(&g_tf_sysdev); if (error != 0) { dprintk(KERN_ERR "tf_device_register(): " "sysdev_register failed (error %d)!\n", error); goto sysdev_register_failed; } /* * Register the char device. */ printk(KERN_INFO "Registering char device %s (%u:%u)\n", TF_DEVICE_BASE_NAME, MAJOR(dev->dev_number), MINOR(dev->dev_number)); error = register_chrdev_region(dev->dev_number, 1, TF_DEVICE_BASE_NAME); if (error != 0) { printk(KERN_ERR "tf_device_register():" " register_chrdev_region failed (error %d)!\n", error); goto register_chrdev_region_failed; } error = cdev_add(&dev->cdev, dev->dev_number, 1); if (error != 0) { printk(KERN_ERR "tf_device_register(): " "cdev_add failed (error %d)!\n", error); goto cdev_add_failed; } /* * Initialize the communication with the Secure World. */ #ifdef CONFIG_TF_TRUSTZONE dev->sm.soft_int_irq = soft_interrupt; #endif error = tf_init(&g_tf_dev.sm); if (error != S_SUCCESS) { dprintk(KERN_ERR "tf_device_register(): " "tf_init failed (error %d)!\n", error); goto init_failed; } #ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS error = tf_self_test_post_init(&(dev_stats->kobj)); /* N.B. error > 0 indicates a POST failure, which will not prevent the module from loading. */ if (error < 0) { dprintk(KERN_ERR "tf_device_register(): " "tf_self_test_post_vectors failed (error %d)!\n", error); goto post_failed; } #endif #ifdef CONFIG_ANDROID tf_class = class_create(THIS_MODULE, TF_DEVICE_BASE_NAME); device_create(tf_class, NULL, dev->dev_number, NULL, TF_DEVICE_BASE_NAME); #endif #ifdef CONFIG_TF_ZEBRA /* * Initializes the /dev/tf_ctrl device node. */ error = tf_ctrl_device_register(); if (error) goto ctrl_failed; #endif #ifdef CONFIG_TF_DRIVER_DEBUG_SUPPORT address_cache_property((unsigned long) &tf_device_register); #endif /* * Successful completion. */ dprintk(KERN_INFO "tf_device_register(): Success\n"); return 0; /* * Error: undo all operations in the reverse order */ #ifdef CONFIG_TF_ZEBRA ctrl_failed: #endif #ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS tf_self_test_post_exit(); post_failed: #endif init_failed: cdev_del(&dev->cdev); cdev_add_failed: unregister_chrdev_region(dev->dev_number, 1); register_chrdev_region_failed: sysdev_unregister(&g_tf_sysdev); sysdev_register_failed: sysdev_class_unregister(&g_tf_device_sys_class); sysdev_class_register_failed: kobject_init_and_add_failed: kobject_del(&g_tf_dev.kobj); #if defined(MODULE) && defined(CONFIG_TF_ZEBRA) #ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS tf_self_test_unregister_device(); self_test_register_device_failed: tf_crypto_hmac_module_exit(); hmac_init_failed: #endif tf_device_mshield_exit(); mshield_init_failed: module_early_init_failed: #endif dprintk(KERN_INFO "tf_device_register(): Failure (error %d)\n", error); return error; }
static void __exit exit_driverfs(void) { sysdev_unregister(&device_oprofile); sysdev_class_unregister(&oprofile_sysclass); }