void switch_dev_unregister(struct switch_dev *sdev)
{
class_device_remove_file(sdev->cdev, &class_device_attr_name);
class_device_remove_file(sdev->cdev, &class_device_attr_state);
class_device_destroy(switch_class, MKDEV(0, sdev->index));
class_set_devdata(sdev->cdev, NULL);
}
static void deactive_work_handle(struct work_struct *work)
{
struct timer_trig_data *timer_data = container_of(work, struct timer_trig_data, deactive_work);
struct led_classdev *led_cdev = timer_data->led_cdev;
class_device_remove_file(led_cdev->class_dev,
&class_device_attr_delay_on);
class_device_remove_file(led_cdev->class_dev,
&class_device_attr_delay_off);
kfree(timer_data);
}
static void timer_trig_deactivate(struct led_classdev *led_cdev)
{
struct timer_trig_data *timer_data = led_cdev->trigger_data;
if (timer_data) {
class_device_remove_file(led_cdev->class_dev,
&class_device_attr_delay_on);
class_device_remove_file(led_cdev->class_dev,
&class_device_attr_delay_off);
del_timer_sync(&timer_data->timer);
kfree(timer_data);
}
}
static void hwtimer_trig_deactivate(struct led_classdev *led_cdev)
{
struct hwtimer_data *timer_data = led_cdev->trigger_data;
if (timer_data) {
class_device_remove_file(led_cdev->class_dev,
&class_device_attr_delay_on);
class_device_remove_file(led_cdev->class_dev,
&class_device_attr_delay_off);
kfree(timer_data);
}
led_cdev->trigger_data = NULL;
return;
}
static void hwtimer_trig_activate(struct led_classdev *led_cdev)
{
int err;
struct hwtimer_data *timer_data;
timer_data = kzalloc(sizeof(struct hwtimer_data), GFP_KERNEL);
if (!timer_data) {
led_cdev->trigger_data = NULL;
return;
}
timer_data->delay_on = 1000;
timer_data->delay_off = 1000;
led_cdev->trigger_data = timer_data;
err = class_device_create_file(led_cdev->class_dev,
&class_device_attr_delay_on);
if (err) goto err_delay_on;
err = class_device_create_file(led_cdev->class_dev,
&class_device_attr_delay_off);
if (err) goto err_delay_off;
return;
err_delay_off:
class_device_remove_file(led_cdev->class_dev,
&class_device_attr_delay_on);
err_delay_on:
led_cdev->trigger_data = NULL;
kfree(timer_data);
printk(KERN_ERR "ledtrig-hwtimer: activate failed\n");
return;
}
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->cdev = class_device_create(switch_class, NULL,
MKDEV(0, sdev->index), NULL, sdev->name);
if (IS_ERR(sdev->cdev))
return PTR_ERR(sdev->cdev);
ret = class_device_create_file(sdev->cdev, &class_device_attr_state);
if (ret < 0)
goto err_create_file_1;
ret = class_device_create_file(sdev->cdev, &class_device_attr_name);
if (ret < 0)
goto err_create_file_2;
class_set_devdata(sdev->cdev, sdev);
sdev->state = 0;
return 0;
err_create_file_2:
class_device_remove_file(sdev->cdev, &class_device_attr_state);
err_create_file_1:
class_device_destroy(switch_class, MKDEV(0, sdev->index));
printk(KERN_ERR "switch: Failed to register driver %s\n", sdev->name);
return ret;
}
/*
* 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 timer_trig_activate(struct led_classdev *led_cdev)
{
struct timer_trig_data *timer_data;
int rc;
timer_data = kzalloc(sizeof(struct timer_trig_data), GFP_KERNEL);
if (!timer_data)
return;
led_cdev->trigger_data = timer_data;
init_timer(&timer_data->timer);
timer_data->timer.function = led_timer_function;
timer_data->timer.data = (unsigned long) led_cdev;
rc = class_device_create_file(led_cdev->class_dev,
&class_device_attr_delay_on);
if (rc) goto err_out;
rc = class_device_create_file(led_cdev->class_dev,
&class_device_attr_delay_off);
if (rc) goto err_out_delayon;
return;
err_out_delayon:
class_device_remove_file(led_cdev->class_dev,
&class_device_attr_delay_on);
err_out:
led_cdev->trigger_data = NULL;
kfree(timer_data);
}
static int omap_pwm_led_remove(struct platform_device *pdev)
{
struct omap_pwm_led *led = pdev_to_omap_pwm_led(pdev);
class_device_remove_file(led->cdev.class_dev,
&class_device_attr_on_period);
class_device_remove_file(led->cdev.class_dev,
&class_device_attr_off_period);
led_classdev_unregister(&led->cdev);
omap_pwm_led_set(&led->cdev, LED_OFF);
if (led->blink_timer != NULL)
omap_dm_timer_free(led->blink_timer);
omap_dm_timer_free(led->intensity_timer);
kfree(led);
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 void __devexit pccard_sysfs_remove_rsrc(struct class_device *class_dev)
{
struct pcmcia_socket *s = class_get_devdata(class_dev);
struct class_device_attribute **attr;
if (s->resource_ops != &pccard_nonstatic_ops)
return;
for (attr = pccard_rsrc_attributes; *attr; attr++)
class_device_remove_file(class_dev, *attr);
}
static void rtc_sysfs_remove_device(struct class_device *class_dev,
struct class_interface *class_intf)
{
if (rtc_does_wakealarm(class_dev))
class_device_remove_file(class_dev,
&class_device_attr_wakealarm);
#ifdef CONFIG_RTC_WAKERS
if (rtc_does_wakealarm(class_dev))
wakers_unregister(class_dev);
#endif
sysfs_remove_group(&class_dev->kobj, &rtc_attr_group);
}
static int dvblo_chardev_release(struct dvblo_chardev *chardev)
{
int rv = SUCCESS, i;
if(chardev->used == 0) {
rv = -EINVAL;
} else if(chardev->hcount > 0) {
rv = -EAGAIN;
} else {
if(chardev->initdone != 0)
dprintk(0, "releasing char device with minor device number %u\n", chardev->minor);
switch(chardev->initlev)
{
case 3:
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
for(i=0; i<(sizeof(clsdev_attrs)/sizeof(clsdev_attrs[0])) && rv == SUCCESS; i++)
class_device_remove_file(chardev->clsdev, &clsdev_attrs[i]);
#endif
case 2:
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
class_device_destroy(dvblo_class, MKDEV(dvblo_char_major, chardev->minor));
#else
/* The old-style "simple" class API */
class_simple_device_remove(MKDEV(dvblo_char_major, chardev->minor));
#endif
case 1:
i = dvblo_adap_destroy(chardev->dvblo);
if(i < 0) {
mprintk(KERN_ALERT, "failed to destroy virtual DVB adapter: %d\n", i);
if(rv == 0)
rv = i;
}
default:
break;
}
if(chardev->initdone != 0)
mprintk(KERN_INFO, "removed character device %s\n", chardev->name);
chardev->initlev = 0;
chardev->initdone = 0;
chardev->used = 0;
}
return rv;
}
static void active_work_handle(struct work_struct *work)
{
int rc;
struct timer_trig_data *timer_data = container_of(work, struct timer_trig_data, active_work);
struct led_classdev *led_cdev = timer_data->led_cdev;
rc = class_device_create_file(led_cdev->class_dev,
&class_device_attr_delay_on);
if (rc) goto err_out;
rc = class_device_create_file(led_cdev->class_dev,
&class_device_attr_delay_off);
if (rc) goto err_out_delayon;
return;
err_out_delayon:
class_device_remove_file(led_cdev->class_dev,
&class_device_attr_delay_on);
err_out:
led_cdev->trigger_data = NULL;
kfree(timer_data);
BUG();
}
