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