static int __init irq_init_sysfs(void) { int ret = sysdev_class_register(&irq_class); if (ret == 0) ret = sysdev_register(&irq_device); return ret; }
static int __init bootstrap_init(void) { int rc; int save_size = mioa701_bootstrap_lg + (sizeof(u32) * 3); rc = sysdev_class_register(&mioa701_sysclass); if (rc) { printk(KERN_ERR "Failed registering mioa701 sys class\n"); return -ENODEV; } rc = sysdev_register(&sysdev_bootstrap); if (rc) { printk(KERN_ERR "Failed registering mioa701 sys device\n"); return -ENODEV; } rc = sysdev_driver_register(&mioa701_sysclass, &driver_bootstrap); if (rc) { printk(KERN_ERR "Failed registering PMU sys driver\n"); return -ENODEV; } save_buffer = kmalloc(save_size, GFP_KERNEL); if (!save_buffer) return -ENOMEM; printk(KERN_INFO "MioA701: allocated %d bytes for bootstrap\n", save_size); return 0; }
static int __init s3c2450_init_pwm(void) { s3c2450_pwm_chan_t *cp; int channel; int ret; printk("S3C PWM Driver, (c) 2006-2007 Samsung Electronics\n"); ret = sysdev_class_register(&pwm_sysclass); if (ret != 0) { printk(KERN_ERR "pwm sysclass registration failed\n"); return -ENODEV; } for (channel = 0; channel < S3C_PWM_CHANNELS; channel++) { cp = &s3c_chans[channel]; memset(cp, 0, sizeof(s3c2450_pwm_chan_t)); cp->number = channel; /* pwm channel irqs are in order.. */ cp->irq = channel + IRQ_TIMER0; /* register system device */ ret = sysdev_register(&cp->sysdev); pr_debug("PWM channel %d , irq %d\n", cp->number, cp->irq); } // s3c2450_timer_setup(3,10,1000,200); return ret; }
static int __init init_driverfs(void) { int error; if (!(error = sysdev_class_register(&oprofile_sysclass))) error = sysdev_register(&device_oprofile); return error; }
static int __init mainstone_irq_device_init(void) { int ret = sysdev_class_register(&mainstone_irq_sysclass); if (ret == 0) ret = sysdev_register(&mainstone_irq_device); return ret; }
static int __init mfp_init_devicefs(void) { if (cpu_is_pxa3xx()) return sysdev_class_register(&pxa3xx_mfp_sysclass); return 0; }
static int __init lpd270_irq_device_init(void) { int ret = sysdev_class_register(&lpd270_irq_sysclass); if (ret == 0) ret = sysdev_register(&lpd270_irq_device); return ret; }
static int init_rttest(void) { int ret, i; spin_lock_init(&rttest_lock); for (i = 0; i < MAX_RT_TEST_MUTEXES; i++) rt_mutex_init(&mutexes[i]); ret = sysdev_class_register(&rttest_sysclass); if (ret) return ret; for (i = 0; i < MAX_RT_TEST_THREADS; i++) { ret = init_test_thread(i); if (ret) break; ret = sysdev_create_file(&thread_data[i].sysdev, &attr_status); if (ret) break; ret = sysdev_create_file(&thread_data[i].sysdev, &attr_command); if (ret) break; } printk("Initializing RT-Tester: %s\n", ret ? "Failed" : "OK" ); return ret; }
static int __init s3c64xx_dma_init(void) { int ret; printk(KERN_INFO "%s: Registering DMA channels\n", __func__); dma_pool = dma_pool_create("DMA-LLI", NULL, sizeof(struct pl080s_lli), 16, 0); if (!dma_pool) { printk(KERN_ERR "%s: failed to create pool\n", __func__); return -ENOMEM; } ret = sysdev_class_register(&dma_sysclass); if (ret) { printk(KERN_ERR "%s: failed to create sysclass\n", __func__); return -ENOMEM; } /* Set all DMA configuration to be DMA, not SDMA */ writel(0xffffff, S3C_SYSREG(0x110)); /* Register standard DMA controllers */ s3c64xx_dma_init1(0, DMACH_UART0, IRQ_DMA0, 0x75000000); s3c64xx_dma_init1(8, DMACH_PCM1_TX, IRQ_DMA1, 0x75100000); return 0; }
/* Initialize the main sysfs entries for edac: * /sys/devices/system/edac * * and children * * Return: 0 SUCCESS * !0 FAILURE */ static int edac_sysfs_memctrl_setup(void) { int err=0; debugf1("%s()\n", __func__); /* create the /sys/devices/system/edac directory */ err = sysdev_class_register(&edac_class); if (!err) { /* Init the MC's kobject */ memset(&edac_memctrl_kobj, 0, sizeof (edac_memctrl_kobj)); edac_memctrl_kobj.parent = &edac_class.kset.kobj; edac_memctrl_kobj.ktype = &ktype_memctrl; /* generate sysfs "..../edac/mc" */ err = kobject_set_name(&edac_memctrl_kobj,"mc"); if (!err) { /* FIXME: maybe new sysdev_create_subdir() */ err = kobject_register(&edac_memctrl_kobj); if (err) debugf1("Failed to register '.../edac/mc'\n"); else debugf1("Registered '.../edac/mc' kobject\n"); } } else debugf1("%s() error=%d\n", __func__, err); return err; }
static int __init omap_battery_init_devicefs(void) { const struct archos_charge_config *charge_cfg; int ret; sysdev_class_register(&omap_battery_sysclass); ret = sysdev_register(&omap_battery0_device); if (ret < 0) return ret; #ifdef CONFIG_POWER_SUPPLY ret = platform_device_register(&archos_battery_device); if (ret < 0) { printk(KERN_INFO "omap_battery_init_devicefs: failed to register battery device\n"); return ret; } #endif sysdev_create_file(&omap_battery0_device, &attr_battery0_charge_state); sysdev_create_file(&omap_battery0_device, &attr_battery0_charge_level); sysdev_create_file(&omap_battery0_device, &attr_battery0_charge_usblevel); /* charge pin */ charge_cfg = omap_get_config( ARCHOS_TAG_CHARGE, struct archos_charge_config ); if (charge_cfg && (hardware_rev < charge_cfg->nrev)) { charge_gpio = charge_cfg->rev[hardware_rev]; GPIO_INIT_OUTPUT( charge_gpio ); omap_set_gpio_dataout( GPIO_PIN( charge_gpio ), 1); } else printk(KERN_DEBUG "omap_battery_init_devicefs: no board configuration found\n"); return 0; }
static int __init cmx2xx_pm_init(void) { int error; error = sysdev_class_register(&cmx2xx_pm_sysclass); if (error == 0) error = sysdev_register(&cmx2xx_pm_device); return error; }
static void __init bast_init(void) { sysdev_class_register(&bast_pm_sysclass); sysdev_register(&bast_pm_sysdev); s3c24xx_fb_set_platdata(&bast_fb_info); platform_add_devices(bast_devices, ARRAY_SIZE(bast_devices)); }
static int __init init_sysfs(void) { int error; error = sysdev_class_register(&oprofile_sysclass); if (!error) error = sysdev_register(&device_oprofile); return error; }
static int __init msm_show_resume_irq_init(void) { int ret = -ENODEV; ret = sysdev_class_register(&msm_show_resume_irq_sysclass); if (ret == 0) ret = sysdev_register(&msm_show_resume_irq_device); return ret; }
static int __init s3c24xx_dma_sysclass_init(void) { int ret = sysdev_class_register(&dma_sysclass); if (ret != 0) printk(KERN_ERR "dma sysclass registration failed\n"); return ret; }
static int __init timer_init_sysfs(void) { int ret = sysdev_class_register(&timer_sysclass); if (ret != 0) return ret; sys_timer->dev.cls = &timer_sysclass; return sysdev_register(&sys_timer->dev); }
static int __init init_driverfs(void) { int ret; if (!(ret = sysdev_class_register(&oprofile_sysclass))) ret = sysdev_register(&device_oprofile); return ret; }
static int __init palmz72_pm_init(void) { int ret = -ENODEV; if (machine_is_palmz72()) { ret = sysdev_class_register(&palmz72_pm_sysclass); if (ret == 0) ret = sysdev_register(&palmz72_pm_device); } return ret; }
static int __init dma_sysclass_init(void) { int ret; ret = sysdev_class_register(&dma_sysclass); if (unlikely(ret)) return ret; return sysfs_create_file(&dma_sysclass.kset.kobj, &attr_devices.attr); }
static int rtl_setup_sysfs(void) { int ret, i; ret = sysdev_class_register(&class_rtl); if (!ret) { for (i = 0; rtl_attributes[i]; i ++) sysdev_class_create_file(&class_rtl, rtl_attributes[i]); } return ret; }
static void __init osiris_init(void) { sysdev_class_register(&osiris_pm_sysclass); sysdev_register(&osiris_pm_sysdev); i2c_register_board_info(0, osiris_i2c_devs, ARRAY_SIZE(osiris_i2c_devs)); platform_add_devices(osiris_devices, ARRAY_SIZE(osiris_devices)); };
static int __init lubbock_irq_device_init(void) { int ret = -ENODEV; if (machine_is_lubbock()) { ret = sysdev_class_register(&lubbock_irq_sysclass); if (ret == 0) ret = sysdev_register(&lubbock_irq_device); } return ret; }
static int __init yf255_irq_device_init(void) { int ret = -ENODEV; if (machine_is_yf255()) { ret = sysdev_class_register(&yf255_irq_sysclass); if (ret == 0) ret = sysdev_register(&yf255_irq_device); } return ret; }
/*! * This function registers AVIC hardware as a system device. * System devices will only be suspended with interrupts disabled, and * after all other devices have been suspended. On resume, they will be * resumed before any other devices, and also with interrupts disabled. * * @return This function returns 0 on success. */ static int __init mxc_avic_sysinit(void) { int ret = 0; ret = sysdev_class_register(&mxc_avic_sysclass); if (ret == 0) { ret = sysdev_register(&mxc_avic_device); } return ret; }
static int __init mainstone_irq_device_init(void) { int ret = -ENODEV; if (machine_is_mainstone()) { ret = sysdev_class_register(&mainstone_irq_sysclass); if (ret == 0) ret = sysdev_register(&mainstone_irq_device); } return ret; }
static int __init init_lapic_sysfs(void) { int error; if (!cpu_has_apic) return 0; /* XXX: remove suspend/resume procs if !apic_pm_state.active? */ error = sysdev_class_register(&lapic_sysclass); if (!error) error = sysdev_register(&device_lapic); return error; }
static int __init leds_init(void) { int ret; ret = sysdev_class_register(&leds_sysclass); if (ret == 0) ret = sysdev_register(&leds_device); if (ret == 0) ret = sysdev_create_file(&leds_device, &attr_event); if (ret == 0) idle_notifier_register(&leds_idle_nb); return ret; }
static int __init init_lapic_nmi_sysfs(void) { int error; if (nmi_active == 0 || nmi_watchdog != NMI_LOCAL_APIC) return 0; error = sysdev_class_register(&nmi_sysclass); if (!error) error = sysdev_register(&device_lapic_nmi); return error; }
int __init cpu_dev_init(void) { int err; err = sysdev_class_register(&cpu_sysdev_class); #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT) if (!err) err = sched_create_sysfs_power_savings_entries(&cpu_sysdev_class); #endif return err; }