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