static void __exit msm_idle_stats_exit(void) { unsigned int nr_cpus = num_possible_cpus(); int i; if (msm_idle_stats_debug_mask & MSM_IDLE_STATS_DEBUG_API) pr_info("%s: enter\n", __func__); cdev_del(&msm_idle_stats_cdev); for (i = nr_cpus - 1; i >= 0; i--) device_destroy( msm_idle_stats_class, msm_idle_stats_dev_nr + i); class_destroy(msm_idle_stats_class); unregister_chrdev_region(msm_idle_stats_dev_nr, nr_cpus); if (msm_idle_stats_debug_mask & MSM_IDLE_STATS_DEBUG_API) pr_info("%s: done\n", __func__); }
static int vdin_remove(struct platform_device *pdev) { int i = 0; device_remove_file(pdev->dev, &dev_attr_debug); unregister_chrdev_region(vdin_devno, VDIN_COUNT); for (i = 0; i < VDIN_COUNT; ++i) { del_timer_sync(&vdin_devp[i]->timer); free_irq(vdin_devp[i]->irq,(void *)vdin_devp[i]); device_destroy(vdin_clsp, MKDEV(MAJOR(vdin_devno), i)); cdev_del(&vdin_devp[i]->cdev); kfree(vdin_devp[i]); } class_destroy(vdin_clsp); printk(KERN_ERR "vdin: driver removed ok.\n"); return 0; }
static void __exit rpigpio_mcleanup(void) { int i = 0; for (i = 0; i < PIN_ARRAY_LEN; i++) { if (i != 0 && i != 1 && i != 5 && i != 6 && i != 12 && i != 13 && i != 16 && i != 19 && i != 20 && i != 21 && i != 26) { std.pin_state_arr[i] = PIN_FREE; gpio_free(i); } } free_irq(gpio_to_irq(RPI_GPIO_IN), THIS_MODULE->name); device_destroy(std.cls, MKDEV(std.mjr, 0)); class_destroy(std.cls); unregister_chrdev(std.mjr, RPIGPIO_MOD_NAME); printk(KERN_NOTICE "[gpio] Removed\n"); }
static int __devexit max77803_led_remove(struct platform_device *pdev) { struct max77803_led_data **led_datas = platform_get_drvdata(pdev); int i; for (i = 0; i != MAX77803_LED_MAX; ++i) { if (led_datas[i] == NULL) continue; cancel_work_sync(&led_datas[i]->work); mutex_destroy(&led_datas[i]->lock); led_classdev_unregister(&led_datas[i]->led); kfree(led_datas[i]); } kfree(led_datas); device_remove_file(flash_dev, &dev_attr_rear_flash); device_destroy(camera_class, 0); class_destroy(camera_class); return 0; }
static void ilo_remove(struct pci_dev *pdev) { int i, minor; struct ilo_hwinfo *ilo_hw = pci_get_drvdata(pdev); clear_device(ilo_hw); minor = MINOR(ilo_hw->cdev.dev); for (i = minor; i < minor + MAX_CCB; i++) device_destroy(ilo_class, MKDEV(ilo_major, i)); cdev_del(&ilo_hw->cdev); ilo_disable_interrupts(ilo_hw); free_irq(pdev->irq, ilo_hw); ilo_unmap_device(pdev, ilo_hw); pci_release_regions(pdev); pci_disable_device(pdev); kfree(ilo_hw); ilo_hwdev[(minor / MAX_CCB)] = 0; }
static void pwm_driver_exit(void) { int i; dev_t devno; /* キャラクタデバイスの登録解除 */ for( i = 0; i < PWMDRV_NUM_DEVS; i++ ) { cdev_del(&(pwm_driver_cdev_array[i])); devno = MKDEV(_pwm_driver_major, _pwm_driver_minor+i); device_destroy(pwm_driver_class, devno); } /* メジャー番号/マイナー番号を取り除く */ devno = MKDEV(_pwm_driver_major,_pwm_driver_minor); unregister_chrdev_region(devno, PWMDRV_NUM_DEVS); class_destroy( pwm_driver_class ); hrtimer_cancel(&refresh_timer); rpi_gpio_unmap(); kfree(pwm_driver_cdev_array); }
static void __exit some_exit(void) { printk(KERN_INFO "%s is exiting\n", DRIVER_NAME); // Remove the device node device_destroy(driver_class, major_numbers); class_destroy(driver_class); // Delete the driver cdev_del(character_device); // Free the IRQ if (interrupt_registered == 0) { free_irq(INTERRUPT_NUMBER, &dev_id); } // Free the major number unregister_chrdev_region(major_numbers, 1); printk(KERN_INFO "%s has exited\n", DRIVER_NAME); }
/* =====================rsz_cleanup=========================== Function is called by the kernel. It unregister the device. */ static void __exit rsz_cleanup(void) { unregister_chrdev_region(dev, 1); device_destroy(rsz_class, dev); class_destroy(rsz_class); driver_unregister(&resizer_driver); /* remove platform device */ platform_device_unregister(&resizer_device); cdev_del(&c_dev); /* unregistering the driver from the kernel */ unregister_chrdev(MAJOR(dev), DRIVER_NAME); } /* End of function resizer_cleanup */
static int adc_remove(struct platform_device *pdev) { struct kp *kp = platform_get_drvdata(pdev); input_unregister_device(kp->input_keytouch); input_unregister_device(kp->input_joystick); input_free_device(kp->input_keytouch); input_free_device(kp->input_joystick); unregister_chrdev(kp->config_major,kp->config_name); if(kp->config_class) { if(kp->config_dev) device_destroy(kp->config_class,MKDEV(kp->config_major,0)); class_destroy(kp->config_class); } kfree(kp); gp_kp=NULL ; return 0; }
/*****************************************EXIT**************************************************/ static void my_exit(void) { int i; dev_t devno = MKDEV(dev_major, dev_minor); if (dev_devices) { for (i = 0; i < NUM_DEVICES; i++) { kfree(dev_devices[i].ramdisk); cdev_del(&dev_devices[i].dev); device_destroy(foo_class, MKDEV(MAJOR(devno), MINOR(devno) + i)); } kfree(dev_devices); class_destroy(foo_class); } unregister_chrdev_region(devno, NUM_DEVICES); printk("DEVICE MODULE UNREGISTERED FROM DEV!\n"); }
// ************************************************************ // // Device Exit : // // // ************************************************************ // static void __exit gps_gpio_exit(void) { gps_dbg("gps_gpio_exit"); device_destroy(gps_class, MKDEV(gps_major, 0)); class_destroy(gps_class); cdev_del(&gps_cdev); unregister_chrdev_region(dev, 1); #if defined(CONFIG_MACH_TCC9300) || defined(CONFIG_MACH_TCC8800) || defined(CONFIG_MACH_TCC8920) // GPS Power off gps_dbg("GPS_PWREN off"); if(machine_is_m801_88() || machine_is_m803()) // demo set { gpio_set_value(TCC_GPG(4), 0); } else if(machine_is_tcc8800() || machine_is_tcc8920()) { gpio_direction_output(TCC_GPEXT1(6), 0); } #elif defined(CONFIG_MACH_TCC8900) if(machine_is_tcc8900()) { gps_dbg("GPS_8900_PWREN off"); gpio_set_value(TCC_GPD(25), 0); } #elif defined(CONFIG_MACH_M805_892X) // GPS Power off gps_dbg("GPS_PWREN off"); if(machine_is_m805_892x()) { if (system_rev == 0x2002 || system_rev == 0x2003 || system_rev == 0x2004 || system_rev == 0x2005) gpio_set_value(TCC_GPE(14), 0); else gpio_set_value(TCC_GPC(6), 0); } #endif gps_dbg("GPS driver unloaded"); }
static int init_gpio(void) { init_result = alloc_chrdev_region( &first, 0, 1, "gpio_drv" ); if( 0 > init_result ) { printk( KERN_ALERT "Device Registration failed\n" ); return -1; } printk("Major Nr: %d\n", MAJOR(first)); if ( (cl = class_create( THIS_MODULE, "gpiodrv" ) ) == NULL ) { printk( KERN_ALERT "Class creation failed\n" ); unregister_chrdev_region( first, 1 ); return -1; } if( device_create( cl, NULL, first, NULL, "gpio_drv%d", 0) == NULL ) { printk( KERN_ALERT "Device creation failed\n" ); class_destroy(cl); unregister_chrdev_region( first, 1 ); return -1; } cdev_init( &c_dev, &FileOps ); if( cdev_add( &c_dev, first, 1 ) == -1) { printk( KERN_ALERT "Device addition failed\n" ); device_destroy( cl, first ); class_destroy( cl ); unregister_chrdev_region( first, 1 ); return -1; } return 0; }
static void __exit cmdq_exit(void) { int32_t status; CMDQ_MSG("CMDQ driver exit begin\n"); device_destroy(gCMDQClass, gCmdqDevNo); class_destroy(gCMDQClass); cdev_del(gCmdqCDev); gCmdqCDev = NULL; unregister_chrdev_region(gCmdqDevNo, 1); platform_driver_unregister(&gCmdqDriver); /* register pm notifier */ status = unregister_pm_notifier(&cmdq_pm_notifier_block); if (0 != status) { CMDQ_ERR("Failed to unregister_pm_notifier(%d)\n", status); } /* Unregister MDP callback */ cmdqCoreRegisterCB(CMDQ_GROUP_MDP, NULL, NULL, NULL, NULL); /* Unregister VENC callback */ cmdqCoreRegisterCB(CMDQ_GROUP_VENC, NULL, NULL, NULL, NULL); /* De-Initialize group callback */ cmdqCoreDeinitGroupCB(); /* De-Initialize cmdq core */ cmdqCoreDeInitialize(); /* De-Initialize cmdq dev related data */ cmdq_dev_deinit(); CMDQ_MSG("CMDQ driver exit end\n"); }
int add_typec_device(struct device *parent, struct typec_device_ops *typec_ops) { struct device *dev; struct device_attribute **attrs = typec_attributes; struct device_attribute *attr; int err; if (!typec_ops || !typec_ops->current_detect || !typec_ops->attached_state_detect || !typec_ops->current_advertise_get || !typec_ops->current_advertise_set || !typec_ops->port_mode_get || !typec_ops->port_mode_set || !typec_ops->dump_regs) { pr_err("%s: ops is NULL\n", __func__); return -1; } dev = device_create(typec_class, NULL, MKDEV(0, 0), typec_ops, "typec_device"); if (IS_ERR(dev)) { pr_err("%s: device_create fail\n", __func__); return -1; } while ((attr = *attrs++)) { err = device_create_file(dev, attr); if (err) { pr_err("%s: device_create_file fail\n", __func__); device_destroy(typec_class, dev->devt); return -1; } } typec_dev = dev; usb_psy = power_supply_get_by_name("usb"); if (!usb_psy) { pr_err("%s USB supply not found\n", __func__); } return 0; }
static void __exit btwlan_em_exit(void) { BTWLAN_EM_DEBUG("btwlan_em_exit ++\n"); if (pbtwlan_em){ cdev_del(&pbtwlan_em->cdev); unregister_chrdev_region(pbtwlan_em->dev_t, 1); device_destroy(pbtwlan_em->cls, pbtwlan_em->dev_t); class_destroy(pbtwlan_em->cls); mutex_destroy(&pbtwlan_em->sem); kfree(pbtwlan_em); pbtwlan_em = NULL; BTWLAN_EM_DEBUG("btwlan_em_exit release source\n"); } BTWLAN_EM_DEBUG("btwlan_em_exit --\n"); }
static int omap_rproc_remove(struct platform_device *pdev) { int major = MAJOR(omap_rproc_dev); struct device *dev = &pdev->dev; struct omap_rproc_platform_data *pdata = dev->platform_data; struct omap_rproc *rproc = platform_get_drvdata(pdev); if (!pdata || !rproc) return -EINVAL; dev_info(dev, "%s removing %s, major: %d, base-minor: %d\n", OMAP_RPROC_NAME, pdata->name, major, rproc->minor); device_destroy(omap_rproc_class, MKDEV(major, rproc->minor)); cdev_del(&rproc->cdev); return 0; }
static int vfd_remove(struct platform_device *pdev) { struct vfd *vfd = platform_get_drvdata(pdev); /* unregister everything */ input_unregister_device(vfd->input); device_remove_file(&pdev->dev, &dev_attr_key); device_remove_file(&pdev->dev, &dev_attr_led); input_free_device(vfd->input); unregister_chrdev(vfd->config_major,vfd->config_name); if(vfd->config_class) { if(vfd->config_dev) device_destroy(vfd->config_class,MKDEV(vfd->config_major,0)); class_destroy(vfd->config_class); } kfree(vfd); gp_vfd = NULL ; return 0; }
/* * Driver Deinitialization */ void __exit SqueueDevDriverExit(void) { unsigned char LoopIndex = 0;/* for looping through all the devices */ for (LoopIndex = 0; LoopIndex < NUMBER_OF_DEVICES; LoopIndex++) { /* Destroy the devices first */ device_destroy(SqueueDevClass, (MKDEV(MAJOR(SqueueDevNumber),LoopIndex))); /* Delete each of the cdevs */ cdev_del(&((&(SqueueBus[LoopIndex]))->cdev)); } /* Free up the allocated memory for all of the device */ kfree(SqueueBus); /* Remove the device class that was created earlier */ class_destroy(SqueueDevClass); /* Unregister devices */ unregister_chrdev_region(MKDEV(MAJOR(SqueueDevNumber), 0), NUMBER_OF_DEVICES); printk(" All Squeue devices and driver are removed ! "); }
/** * uio_unregister_device - unregister a industrial IO device * @info: UIO device capabilities * */ void uio_unregister_device(struct uio_info *info) { struct uio_device *idev; if (!info || !info->uio_dev) return; idev = info->uio_dev; uio_free_minor(idev); if (info->irq && (info->irq != UIO_IRQ_CUSTOM)) free_irq(info->irq, idev); uio_dev_del_attributes(idev); device_destroy(&uio_class, MKDEV(uio_major, idev->minor)); kfree(idev); return; }
static void WIFI_exit(void) { dev_t dev = MKDEV(WIFI_major, 0); // retflag = 0; if(pWIFIDev) { device_destroy(pWIFIClass, dev); pWIFIDev = NULL; } if(pWIFIClass) { class_destroy(pWIFIClass); pWIFIClass = NULL; } cdev_del(&WIFI_cdev); unregister_chrdev_region(dev, WIFI_devs); WIFI_INFO_FUNC("%s driver removed.\n", WIFI_DRIVER_NAME); }
static void drv_exit(void) #endif { gcmkHEADER(); gcmkASSERT(gpuClass != gcvNULL); device_destroy(gpuClass, MKDEV(major, 0)); class_destroy(gpuClass); unregister_chrdev(major, DEVICE_NAME); gcmkVERIFY_OK(gckGALDEVICE_Stop(galDevice)); gcmkVERIFY_OK(gckGALDEVICE_Destroy(galDevice)); if(gckDEBUGFS_IsEnabled()) { gckDEBUGFS_Terminate(); } gcmkFOOTER_NO(); }
static int __devexit elmo_remove(struct platform_device *pdev) { extern void gpio_wan_exit(void *); log_debug("elmo_remove::removing elmo device\n"); wan_set_power_status(WAN_INVALID); /* clear the PMIC event handler */ pmic_power_event_unsub(PWR_IT_ONOFD2I, wan_tph_notify); if (wan_dev != NULL) { device_destroy(wan_class, MKDEV(wan_major, 0)); wan_dev = NULL; class_destroy(wan_class); unregister_chrdev(wan_major, WAN_STRING_DEV); } free_irq(gpio_wan_fw_ready_irq(),NULL); free_irq(gpio_wan_mhi_irq(),NULL); return 0; }
static void cleanup(void) { int i; unsigned long flags; spin_lock_irqsave(&dgnc_poll_lock, flags); dgnc_poll_stop = 1; spin_unlock_irqrestore(&dgnc_poll_lock, flags); /* Turn off poller right away. */ del_timer_sync(&dgnc_poll_timer); device_destroy(dgnc_class, MKDEV(dgnc_major, 0)); class_destroy(dgnc_class); unregister_chrdev(dgnc_major, "dgnc"); for (i = 0; i < dgnc_num_boards; ++i) { dgnc_cleanup_tty(dgnc_board[i]); dgnc_cleanup_board(dgnc_board[i]); } }
static void audiodev_cleanup_module(int device_added) { dev_t devno = MKDEV(audiostub_major, audiostub_minor); int i; deinit_audioport(); /* Get rid of our char dev entries */ if (audiodev_devices) { for (i = 0; i < device_added; i++) { cdev_del(&audiodev_devices[i]); device_destroy(audiodev_class, MKDEV(audiostub_major, audiostub_minor + i)); } kfree(audiodev_devices); } class_destroy(audiodev_class); unregister_chrdev_region(devno, AUDIO_DEVICE_CNT); }
/** * exm_unregister_device - unregister a industrial IO device * @info: EXM device capabilities * */ void exm_unregister_device(struct exm_info *info) { struct exm_device *idev; if (!info || !info->exm_dev) return; idev = info->exm_dev; exm_free_minor(idev); if (info->irq && (info->irq != EXM_IRQ_CUSTOM)) free_irq(info->irq, idev); exm_dev_del_attributes(idev); device_destroy(&exm_class, MKDEV(exm_major, idev->minor)); kfree(idev); return; }
static int __devexit bfspi_release() { //struct bfspi_data *bfspi = (struct bfspi_data *)spi->drv_data; /* make sure ops on existing fds can abort cleanly */ //spin_lock_irq(&bfspi->spi_lock); //bfspi->spi = NULL; //spi_set_drvdata(spi, NULL); //spin_unlock_irq(&bfspi->spi_lock); /* prevent new opens */ mutex_lock(&device_list_lock); //list_del(&bfspi->device_entry); device_destroy(bfspi_class, bfspi->devt); clear_bit(MINOR(bfspi->devt), minors); if (bfspi->users == 0) kfree(bfspi); mutex_unlock(&device_list_lock); return 0; }
static int __devinit ldm4_probe(struct platform_device *dev) { int ret; PRINT(); if (0 == dev_cnt) { major = register_chrdev(0, "ldm4", &ldm4_fops); if (major < 0) { return major; } ldm4_cls = class_create(THIS_MODULE, "ldm4"); if (NULL == ldm4_cls) { ret = -1; goto class_create_err; } } ldm4_dev[dev_cnt] = device_create(ldm4_cls, NULL, MKDEV(major, dev_cnt), NULL, "%s", dev->name); if (NULL == ldm4_dev[dev_cnt]) { ret = -1; goto device_create_err; } dev_cnt++; return 0; device_create_err: while (dev_cnt > 0) { device_destroy(ldm4_cls, MKDEV(major, dev_cnt - 1)); dev_cnt--; } class_destroy(ldm4_cls); class_create_err: unregister_chrdev(major, "ldm4"); return ret; }
int switch_dev_register(struct switch_dev *sdev) { int ret; if (!switch_class) { ret = create_switch_class(); if (ret < 0) return ret; } sdev->index = atomic_inc_return(&device_count); sdev->dev = device_create(switch_class, NULL, MKDEV(0, sdev->index), NULL, sdev->name); if (IS_ERR(sdev->dev)) return PTR_ERR(sdev->dev); ret = device_create_file(sdev->dev, &dev_attr_state); if (ret < 0) goto err_create_file_1; ret = device_create_file(sdev->dev, &dev_attr_name); if (ret < 0) goto err_create_file_2; ret = device_create_file(sdev->dev, &dev_attr_gps_en); if (ret < 0) goto err_create_file_1; ret = device_create_file(sdev->dev, &dev_attr_gps_rst); if (ret < 0) goto err_create_file_1; dev_set_drvdata(sdev->dev, sdev); sdev->state = 0; return 0; err_create_file_2: device_remove_file(sdev->dev, &dev_attr_state); err_create_file_1: device_destroy(switch_class, MKDEV(0, sdev->index)); printk(KERN_ERR "switch: Failed to register driver %s\n", sdev->name); return ret; }
static void drv_exit(void) #endif { gcmkHEADER(); #ifdef CONFIG_ANDROID_RESERVED_MEMORY_ACCOUNT task_free_unregister(&task_nb); unregister_reserved_memory_account(&viv_gpu_resmem_handler); #endif gcmkASSERT(gpuClass != gcvNULL); device_destroy(gpuClass, MKDEV(major, 0)); class_destroy(gpuClass); unregister_chrdev(major, DRV_NAME); gcmkVERIFY_OK(gckGALDEVICE_Stop(galDevice)); gcmkVERIFY_OK(gckGALDEVICE_Destroy(galDevice)); if(gckDebugFileSystemIsEnabled()) { gckDebugFileSystemTerminate(); } #if ENABLE_GPU_CLOCK_BY_DRIVER && LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28) { # if 0 struct clk * clk = NULL; #if defined(CONFIG_PXA_DVFM) && (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29)) gc_pwr(0); #endif clk = clk_get(NULL, "GCCLK"); clk_disable(clk); # endif } #endif gcmkFOOTER_NO(); }
static void WMT_exit(void) { dev_t dev = MKDEV(gWmtMajor, 0); #if CONSYS_EARLYSUSPEND_ENABLE unregister_early_suspend(&wmt_early_suspend_handler); osal_sleepable_lock_deinit(&g_es_lr_lock); WMT_INFO_FUNC("unregister_early_suspend finished\n"); #endif #if CONSYS_WMT_REG_SUSPEND_CB_ENABLE unregister_pm_notifier(&wmt_pm_notifier_block); #endif wmt_lib_deinit(); #if CFG_WMT_DBG_SUPPORT wmt_dev_dbg_remove(); #endif #if CFG_WMT_PROC_FOR_AEE wmt_dev_proc_for_aee_remove(); #endif cdev_del(&gWmtCdev); unregister_chrdev_region(dev, WMT_DEV_NUM); gWmtMajor = -1; #if REMOVE_MK_NODE device_destroy(wmt_class, MKDEV(gWmtMajor, 0)); class_destroy(wmt_class); wmt_class = NULL; #endif #ifdef MTK_WMT_WAKELOCK_SUPPORT WMT_WARN_FUNC("destroy func_on_off_wake_lock\n"); wake_lock_destroy(&func_on_off_wake_lock); #endif stp_drv_exit(); WMT_INFO_FUNC("done\n"); }