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