/* * test_classdev_reg * make test call to class_device_register * and if that returns successful then * make call to class_device_unregister */ static int test_classdev_reg() { int rc = 0; if (class_device_register(&test_class_dev)) { printk("tbase: Failed to register class device\n"); rc = 1; } else { printk("tbase: Registered class device\n"); /* make class device sysfs file */ if (class_device_create_file(&test_class_dev, &class_device_attr_test_id)) { rc = 1; printk("tbase: Failed to create class device sysfs file\n"); } else { printk("tbase: Created class device sysfs file\n"); class_device_remove_file(&test_class_dev, &class_device_attr_test_id); } class_device_unregister(&test_class_dev); } return rc; }
static void key_int_drv_exit(void) { unregister_chrdev(major, "key"); class_device_unregister(key_int_drv_class_dev); class_destroy(key_int_drv_class); iounmap(gpfcon); iounmap(gpgcon); }
static void first_drv_exit(void) { unregister_chrdev(major, "first_drv"); // 卸载 class_device_unregister(firstdrv_class_dev); class_destroy(firstdrv_class); iounmap(gpfcon); }
static void sixth_drv_exit(void) { unregister_chrdev(major, "sixth_drv"); class_device_unregister(sixthdrv_class_dev); class_destroy(sixthdrv_class); // iounmap(gpfcon); return 0; }
static void first_drv_exit(void) //exit { unregister_chrdev(major, "first_drv"); //卸载 class_device_unregister(firstdrv_class_devs); class_destroy(firstdrv_class); return ; }
static void fifth_drv_exit(void) { unregister_chrdev(major, "fifth_drv"); class_device_unregister(fifthdrv_class_dev); class_destroy(fifthdrv_class); iounmap(gpfcon); iounmap(gpgcon); return 0; }
static int __devexit goldfish_switch_remove(struct platform_device *pdev) { struct goldfish_switch *qs = platform_get_drvdata(pdev); writel(0, qs->base + SW_INT_ENABLE); free_irq(qs->irq, qs); class_device_unregister(qs->cdev); kfree(qs); return 0; }
static void third_driver_exit(void) { unregister_chrdev(major, "third driver"); class_destroy(third_driver_class); class_device_unregister(third_driver_class_device); // unmap GPIO iounmap(gpfcon); iounmap(gpgcon); }
/** * hwmon_device_unregister - removes the previously registered class device * * @cdev: the class device to destroy */ void hwmon_device_unregister(struct class_device *cdev) { int id; if (sscanf(cdev->class_id, HWMON_ID_FORMAT, &id) == 1) { class_device_unregister(cdev); idr_remove(&hwmon_idr, id); } else dev_dbg(cdev->dev, "hwmon_device_unregister() failed: bad class ID!\n"); }
void sixth_exit(void) { unregister_chrdev(major, "sixth_drv"); //名字不重要,"sec"也可以 class_device_unregister(sixth_class_device); //先unregister, 再destroy class_destroy(sixth_class); iounmap(gpgcon); iounmap(gpgdat); }
static int at24cxx_detach(struct i2c_client *client) { printk("at24cxx_detach\n"); class_device_unregister(at24cxx_class_dev); class_destroy(cls); unregister_chrdev(major, "at2cxx"); i2c_detach_client(client); kfree(i2c_get_clientdata(client)); return 0; }
/** * led_classdev_unregister - unregisters a object of led_properties class. * @led_cdev: the led device to unreigister * * Unregisters a previously registered via led_classdev_register object. */ void led_classdev_unregister(struct led_classdev *led_cdev) { class_device_remove_file(led_cdev->class_dev, &class_device_attr_brightness); #ifdef CONFIG_LEDS_TRIGGERS class_device_remove_file(led_cdev->class_dev, &class_device_attr_trigger); write_lock(&led_cdev->trigger_lock); if (led_cdev->trigger) led_trigger_set(led_cdev, NULL); write_unlock(&led_cdev->trigger_lock); #endif class_device_unregister(led_cdev->class_dev); write_lock(&leds_list_lock); list_del(&led_cdev->node); write_unlock(&leds_list_lock); }
static int __devinit goldfish_switch_probe(struct platform_device *pdev) { int ret; struct resource *r; struct goldfish_switch *qs; uint32_t base; uint32_t name_len; r = platform_get_resource(pdev, IORESOURCE_MEM, 0); if(r == NULL) { ret = -ENODEV; goto err_no_io_base; } base = IO_ADDRESS(r->start - IO_START); name_len = readl(base + SW_NAME_LEN); qs = kzalloc(sizeof(*qs) + name_len + 1, GFP_KERNEL); if(qs == NULL) { ret = -ENOMEM; goto err_qs_alloc_failed; } platform_set_drvdata(pdev, qs); qs->base = base; r = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if(r == NULL) { ret = -ENODEV; goto err_no_irq; } qs->irq = r->start; writel(qs->name, base + SW_NAME_PTR); qs->name[name_len] = '\0'; writel(0, base + SW_INT_ENABLE); qs->flags = readl(base + SW_FLAGS); qs->state = readl(base + SW_STATE); INIT_WORK(&qs->work, goldfish_switch_work); qs->cdev = class_device_create(goldfish_switch_class, NULL, 0, &pdev->dev, "%s", qs->name); if(unlikely(IS_ERR(qs->cdev))) { ret = PTR_ERR(qs->cdev); goto err_class_device_create_failed; } class_set_devdata(qs->cdev, qs); ret = class_device_create_file(qs->cdev, &class_device_attr_state); if(ret) goto err_class_device_create_file_failed; ret = class_device_create_file(qs->cdev, &class_device_attr_direction); if(ret) goto err_class_device_create_file_failed; ret = request_irq(qs->irq, goldfish_switch_interrupt, IRQF_SHARED, "goldfish_switch", qs); if(ret) goto err_request_irq_failed; writel(1, base + SW_INT_ENABLE); return 0; // free_irq(qs->irq, qs); err_request_irq_failed: err_class_device_create_file_failed: class_device_unregister(qs->cdev); err_class_device_create_failed: err_no_irq: kfree(qs); err_qs_alloc_failed: err_no_io_base: printk("goldfish_switch_probe failed %d\n", ret); return ret; }