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