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; }
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; }
/** * led_classdev_register - register a new object of led_classdev class. * @dev: The device to register. * @led_cdev: the led_classdev structure for this device. */ int led_classdev_register(struct device *parent, struct led_classdev *led_cdev) { led_cdev->class_dev = class_device_create(leds_class, NULL, 0, parent, "%s", led_cdev->name); if (unlikely(IS_ERR(led_cdev->class_dev))) return PTR_ERR(led_cdev->class_dev); class_set_devdata(led_cdev->class_dev, led_cdev); /* register the attributes */ class_device_create_file(led_cdev->class_dev, &class_device_attr_brightness); /* add to the list of leds */ write_lock(&leds_list_lock); list_add_tail(&led_cdev->node, &leds_list); write_unlock(&leds_list_lock); #ifdef CONFIG_LEDS_TRIGGERS rwlock_init(&led_cdev->trigger_lock); led_trigger_set_default(led_cdev); class_device_create_file(led_cdev->class_dev, &class_device_attr_trigger); #endif printk(KERN_INFO "Registered led device: %s\n", led_cdev->class_dev->class_id); return 0; }
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); }
/* * 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 int rtc_sysfs_add_device(struct class_device *class_dev, struct class_interface *class_intf) { int err; dev_dbg(class_dev->dev, "rtc intf: sysfs\n"); err = sysfs_create_group(&class_dev->kobj, &rtc_attr_group); if (err) dev_err(class_dev->dev, "failed to create %s\n", "sysfs attributes"); else if (rtc_does_wakealarm(class_dev)) { /* not all RTCs support both alarms and wakeup */ err = class_device_create_file(class_dev, &class_device_attr_wakealarm); if (err) { dev_err(class_dev->dev, "failed to create %s\n", "alarm attribute"); sysfs_remove_group(&class_dev->kobj, &rtc_attr_group); } #ifdef CONFIG_RTC_WAKERS err = wakers_register(class_dev); if (err) { dev_err(class_dev->dev, "failed to create %s\n", "alarm attribute"); sysfs_remove_group(&class_dev->kobj, &rtc_attr_group); } #endif } return err; }
static int i2cdev_attach_adapter(struct i2c_adapter *adap) { struct i2c_dev *i2c_dev; struct device *dev; i2c_dev = get_free_i2c_dev(adap); if (IS_ERR(i2c_dev)) return PTR_ERR(i2c_dev); pr_debug("i2c-dev: adapter [%s] registered as minor %d\n", adap->name, i2c_dev->minor); /* register this i2c device with the driver core */ i2c_dev->adap = adap; if (adap->dev.parent == &platform_bus) dev = &adap->dev; else dev = adap->dev.parent; i2c_dev->class_dev = class_device_create(i2c_dev_class, NULL, MKDEV(I2C_MAJOR, i2c_dev->minor), dev, "i2c-%d", i2c_dev->minor); if (!i2c_dev->class_dev) goto error; class_device_create_file(i2c_dev->class_dev, &class_device_attr_name); return 0; error: return_i2c_dev(i2c_dev); kfree(i2c_dev); return -ENODEV; }
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(); }
static int __devinit pccard_sysfs_add_rsrc(struct class_device *class_dev) { struct pcmcia_socket *s = class_get_devdata(class_dev); struct class_device_attribute **attr; int ret = 0; if (s->resource_ops != &pccard_nonstatic_ops) return 0; for (attr = pccard_rsrc_attributes; *attr; attr++) { ret = class_device_create_file(class_dev, *attr); if (ret) break; } return ret; }
static int dvblo_chardev_init(struct dvblo_chardev *chardev, struct dvblo_chardev_config *cfg) { int rv = SUCCESS, i; if(chardev->used != 0) { rv = -EINVAL; } else { chardev->used = 1; chardev->initlev = 0; chardev->initdone = 0; do { dprintk(DBGLEV_ALL, "initializing char device with minor device number %u\n", chardev->minor); i = snprintf(chardev->name, sizeof(chardev->name), DVBLO_NAME "%d", chardev->minor); if(i < 0 || i >= sizeof(chardev->name)) { if(i < 0) rv = i; else rv = -ENOBUFS; break; } chardev->hcount = 0; chardev->cfg.ts_sz = DVBLO_TS_SZ; chardev->cfg.hwrbuf_sz = 20 * chardev->cfg.ts_sz; i = dvblo_adap_create(chardev->minor, cfg ? &cfg->dvbcfg : NULL, &chardev->dvblo); if(i < 0) { mprintk(KERN_ALERT, "failed to create virtual DVB adapter: %d\n", i); rv = i; break; } chardev->initlev++; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15) /* In 2.6.15, class_device_create() got a pointer to the parent device (if any) as its second param */ chardev->clsdev = class_device_create(dvblo_class, NULL, MKDEV(dvblo_char_major, chardev->minor), NULL, chardev->name); #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13) /* class_device_create() first appeared in 2.6.13 */ chardev->clsdev = class_device_create(dvblo_class, MKDEV(dvblo_char_major, chardev->minor), NULL, chardev->name); #else /* The old-style "simple" class API */ chardev->clsdev = class_simple_device_add(dvblo_class, MKDEV(dvblo_char_major, chardev->minor), NULL, chardev->name); #endif if(IS_ERR(chardev->clsdev)) { rv = PTR_ERR(chardev->clsdev); mprintk(KERN_ALERT, "failed to create device class \"%s\": %d\n", chardev->name, rv); break; } chardev->initlev++; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13) for(i=0; i<(sizeof(clsdev_attrs)/sizeof(clsdev_attrs[0])) && rv == SUCCESS; i++) rv = class_device_create_file(chardev->clsdev, &clsdev_attrs[i]); if(rv != SUCCESS) break; #endif chardev->initlev++; mprintk(KERN_INFO, "added character device %s\n", chardev->name); } while(0); if(rv != 0) dvblo_chardev_release(chardev); // error cleanup } return rv; }
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; }
static int omap_pwm_led_probe(struct platform_device *pdev) { struct omap_pwm_led_platform_data *pdata = pdev->dev.platform_data; struct omap_pwm_led *led; int ret; led = kzalloc(sizeof(struct omap_pwm_led), GFP_KERNEL); if (led == NULL) { dev_err(&pdev->dev, "No memory for device\n"); return -ENOMEM; } platform_set_drvdata(pdev, led); led->cdev.brightness_set = omap_pwm_led_set; led->cdev.default_trigger = NULL; led->cdev.name = pdata->name; led->pdata = pdata; dev_info(&pdev->dev, "OMAP PWM LED (%s) at GP timer %d/%d\n", pdata->name, pdata->intensity_timer, pdata->blink_timer); /* register our new led device */ ret = led_classdev_register(&pdev->dev, &led->cdev); if (ret < 0) { dev_err(&pdev->dev, "led_classdev_register failed\n"); goto error_classdev; } /* get related dm timers */ led->intensity_timer = omap_dm_timer_request_specific(pdata->intensity_timer); if (led->intensity_timer == NULL) { dev_err(&pdev->dev, "failed to request intensity pwm timer\n"); ret = -ENODEV; goto error_intensity; } omap_dm_timer_disable(led->intensity_timer); if (pdata->blink_timer != 0) { led->blink_timer = omap_dm_timer_request_specific(pdata->blink_timer); if (led->blink_timer == NULL) { dev_err(&pdev->dev, "failed to request blinking pwm timer\n"); ret = -ENODEV; goto error_blink; } omap_dm_timer_disable(led->blink_timer); class_device_create_file(led->cdev.class_dev, &class_device_attr_on_period); class_device_create_file(led->cdev.class_dev, &class_device_attr_off_period); } return 0; error_blink: omap_dm_timer_free(led->intensity_timer); error_intensity: led_classdev_unregister(&led->cdev); error_classdev: kfree(led); return ret; }