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