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 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; }
int dma_create_sysfs_files(struct dma_channel *chan, struct dma_info *info) { struct sys_device *dev = &chan->dev; char name[16]; int ret; dev->id = chan->vchan; dev->cls = &dma_sysclass; ret = sysdev_register(dev); if (ret) return ret; ret |= sysdev_create_file(dev, &attr_dev_id); ret |= sysdev_create_file(dev, &attr_count); ret |= sysdev_create_file(dev, &attr_mode); ret |= sysdev_create_file(dev, &attr_flags); ret |= sysdev_create_file(dev, &attr_config); if (unlikely(ret)) { dev_err(&info->pdev->dev, "Failed creating attrs\n"); return ret; } snprintf(name, sizeof(name), "dma%d", chan->chan); return sysfs_create_link(&info->pdev->dev.kobj, &dev->kobj, name); }
static int dvfs_sysdev_ctrl_init(void) { int err; err = sysdev_class_register(&dvfs_sysclass); if (!err) err = sysdev_register(&dvfs_device); if (!err) { err = sysdev_create_file(&dvfs_device, &attr_enable); err = sysdev_create_file(&dvfs_device, &attr_status); } return err; }
/* * register_node - Setup a driverfs device for a node. * @num - Node number to use when creating the device. * * Initialize and register the node device. */ int __init register_node(struct node *node, int num, struct node *parent) { int error; node->cpumap = node_to_cpumask(num); node->sysdev.id = num; node->sysdev.cls = &node_class; error = sys_device_register(&node->sysdev); if (!error){ sysdev_create_file(&node->sysdev, &attr_cpumap); sysdev_create_file(&node->sysdev, &attr_meminfo); } return error; }
static int register_mmu_stats(struct sys_device *s) { if (!mmu_stats_supported) return 0; sysdev_create_file(s, &attr_mmustat_enable); return sysfs_create_group(&s->kobj, &mmu_stat_group); }
/** * cmm_sysfs_register - Register with sysfs * * Return value: * 0 on success / other on failure **/ static int cmm_sysfs_register(struct sys_device *sysdev) { int i, rc; if ((rc = sysdev_class_register(&cmm_sysdev_class))) return rc; sysdev->id = 0; sysdev->cls = &cmm_sysdev_class; if ((rc = sysdev_register(sysdev))) goto class_unregister; for (i = 0; i < ARRAY_SIZE(cmm_attrs); i++) { if ((rc = sysdev_create_file(sysdev, cmm_attrs[i]))) goto fail; } return 0; fail: while (--i >= 0) sysdev_remove_file(sysdev, cmm_attrs[i]); sysdev_unregister(sysdev); class_unregister: sysdev_class_unregister(&cmm_sysdev_class); return rc; }
/* * register_node - Setup a sysfs device for a node. * @num - Node number to use when creating the device. * * Initialize and register the node device. */ int register_node(struct node *node, int num, struct node *parent) { int error; node->sysdev.id = num; node->sysdev.cls = &node_class; error = sysdev_register(&node->sysdev); if (!error){ sysdev_create_file(&node->sysdev, &attr_cpumap); sysdev_create_file(&node->sysdev, &attr_meminfo); sysdev_create_file(&node->sysdev, &attr_numastat); sysdev_create_file(&node->sysdev, &attr_distance); } return error; }
static int __init topology_init(void) { int cpu; register_nodes(); register_cpu_notifier(&sysfs_cpu_nb); for_each_possible_cpu(cpu) { struct cpu *c = &per_cpu(cpu_devices, cpu); /* * For now, we just see if the system supports making * the RTAS calls for CPU hotplug. But, there may be a * more comprehensive way to do this for an individual * CPU. For instance, the boot cpu might never be valid * for hotplugging. */ if (ppc_md.cpu_die) c->hotpluggable = 1; if (cpu_online(cpu) || c->hotpluggable) { register_cpu(c, cpu); sysdev_create_file(&c->sysdev, &attr_physical_id); } if (cpu_online(cpu)) register_cpu_online(cpu); } return 0; }
static void register_cpu_online(unsigned int cpu) { struct cpu *c = &per_cpu(cpu_devices, cpu); struct sys_device *s = &c->sysdev; int i; for (i = 0; i < ARRAY_SIZE(cpu_core_attrs); i++) sysdev_create_file(s, &cpu_core_attrs[i]); register_mmu_stats(s); }
int __init dma_create_sysfs_files(struct dma_channel *chan) { struct sys_device *dev = &chan->dev; int ret; dev->id = chan->chan; dev->cls = &dma_sysclass; ret = sysdev_register(dev); if (ret) return ret; sysdev_create_file(dev, &attr_dev_id); sysdev_create_file(dev, &attr_count); sysdev_create_file(dev, &attr_mode); sysdev_create_file(dev, &attr_flags); sysdev_create_file(dev, &attr_config); return 0; }
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_cpu_idle_sysfs(void) { int error = sysdev_class_register(&cpu_idle_sysclass); if (!error) error = sysdev_register(&device_cpu_idle); if (!error) error = sysdev_create_file( &device_cpu_idle, &attr_idle_count); return error; }
static int mx50_accessory_sysdev_ctrl_init(void) { int err = 0; err = sysdev_class_register(&mx50_accessory_sysclass); if (!err) err = sysdev_register(&mx50_accessory_device); if (!err) { sysdev_create_file(&mx50_accessory_device, &attr_mx50_accessory_state); } return err; }
int cpu_add_sysdev_attr(struct sysdev_attribute *attr) { int cpu; mutex_lock(&cpu_mutex); for_each_possible_cpu(cpu) { sysdev_create_file(get_cpu_sysdev(cpu), attr); } mutex_unlock(&cpu_mutex); return 0; }
/* * register_node - Setup a sysfs device for a node. * @num - Node number to use when creating the device. * * Initialize and register the node device. */ int register_node(struct node *node, int num, struct node *parent) { int error; node->sysdev.id = num; node->sysdev.cls = &node_class; error = sysdev_register(&node->sysdev); if (!error){ sysdev_create_file(&node->sysdev, &attr_cpumap); sysdev_create_file(&node->sysdev, &attr_cpulist); sysdev_create_file(&node->sysdev, &attr_meminfo); sysdev_create_file(&node->sysdev, &attr_numastat); sysdev_create_file(&node->sysdev, &attr_distance); scan_unevictable_register_node(node); hugetlb_register_node(node); compaction_register_node(node); } return error; }
static void sensorinfo_create_files(struct sys_device *dev, struct sysdev_attribute files[], int size) { int i; for (i = 0; i < size; i++) { int err = sysdev_create_file(dev, &files[i]); if (err) { pr_err("%s: sysdev_create_file(%s)=%d\n", __func__, files[i].attr.name, err); return; } } }
static int __init qfprom_create_files(struct sys_device *dev, struct sysdev_attribute files[], int size) { int i; for (i = 0; i < size; i++) { int err = sysdev_create_file(dev, &files[i]); if (err) { pr_err("%s: sysdev_create_file(%s)=%d\n", __func__, files[i].attr.name, err); return err; } } return 0; }
static void register_cpu_online(unsigned int cpu) { struct cpu *c = &per_cpu(cpu_devices, cpu); struct sys_device *s = &c->sysdev; struct sysdev_attribute *attrs, *pmc_attrs; int i, nattrs; if (!firmware_has_feature(FW_FEATURE_ISERIES) && cpu_has_feature(CPU_FTR_SMT)) sysdev_create_file(s, &attr_smt_snooze_delay); /* PMC stuff */ switch (cur_cpu_spec->pmc_type) { case PPC_PMC_IBM: attrs = ibm_common_attrs; nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute); pmc_attrs = ibm_pmc_attrs; break; case PPC_PMC_PA6T: /* PA Semi starts counting at PMC0 */ attrs = pa6t_attrs; nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute); pmc_attrs = NULL; break; default: attrs = NULL; nattrs = 0; pmc_attrs = NULL; } for (i = 0; i < nattrs; i++) sysdev_create_file(s, &attrs[i]); if (pmc_attrs) for (i = 0; i < cur_cpu_spec->num_pmcs; i++) sysdev_create_file(s, &pmc_attrs[i]); if (cpu_has_feature(CPU_FTR_MMCRA)) sysdev_create_file(s, &attr_mmcra); if (cpu_has_feature(CPU_FTR_PURR)) sysdev_create_file(s, &attr_purr); if (cpu_has_feature(CPU_FTR_SPURR)) sysdev_create_file(s, &attr_spurr); if (cpu_has_feature(CPU_FTR_DSCR)) sysdev_create_file(s, &attr_dscr); }
static int __init topology_init(void) { int cpu; struct node *parent = NULL; register_nodes(); register_cpu_notifier(&sysfs_cpu_nb); for_each_cpu(cpu) { struct cpu *c = &per_cpu(cpu_devices, cpu); #ifdef CONFIG_NUMA /* The node to which a cpu belongs can't be known * until the cpu is made present. */ parent = NULL; if (cpu_present(cpu)) parent = &node_devices[cpu_to_node(cpu)]; #endif /* * For now, we just see if the system supports making * the RTAS calls for CPU hotplug. But, there may be a * more comprehensive way to do this for an individual * CPU. For instance, the boot cpu might never be valid * for hotplugging. */ if (!ppc_md.cpu_die) c->no_control = 1; if (cpu_online(cpu) || (c->no_control == 0)) { register_cpu(c, cpu, parent); sysdev_create_file(&c->sysdev, &attr_physical_id); } if (cpu_online(cpu)) register_cpu_online(cpu); } return 0; }
/* * register_cpu - Setup a driverfs device for a CPU. * @cpu - cpu->hotpluggable field set to 1 will generate a control file in * sysfs for this CPU. * @num - CPU number to use when creating the device. * * Initialize and register the CPU device. */ int __devinit register_cpu(struct cpu *cpu, int num) { int error; cpu->node_id = cpu_to_node(num); cpu->sysdev.id = num; cpu->sysdev.cls = &cpu_sysdev_class; error = sysdev_register(&cpu->sysdev); if (!error && cpu->hotpluggable) register_cpu_control(cpu); if (!error) cpu_sys_devices[num] = &cpu->sysdev; if (!error) register_cpu_under_node(num, cpu_to_node(num)); #ifdef CONFIG_KEXEC if (!error) error = sysdev_create_file(&cpu->sysdev, &attr_crash_notes); #endif return error; }
/* * MSM LED Trigger Sys Device Register * * 1. Torch Mode * enable: $ echo "1" > /sys/devices/system/led-flash/led-flash0/torch * disable: $ echo "0" > /sys/devices/system/led-flash/led-flash0/torch * * 2. Flash Mode * enable: $ echo "1" > /sys/devices/system/led-flash/led-flash0/flash * disable: $ echo "0" > /sys/devices/system/led-flash/led-flash0/flash */ static int32_t msm_led_trigger_register_sysdev(struct msm_led_flash_ctrl_t *fctrl) { int32_t i, rc; rc = sysdev_class_register(&msm_led_trigger_sysdev_class); if (rc) { return rc; } msm_led_trigger_sysdev.id = 0; msm_led_trigger_sysdev.cls = &msm_led_trigger_sysdev_class; rc = sysdev_register(&msm_led_trigger_sysdev); if (rc) { sysdev_class_unregister(&msm_led_trigger_sysdev_class); return rc; } for (i = 0; i < ARRAY_SIZE(msm_led_trigger_sysdev_attrs); ++i) { rc = sysdev_create_file(&msm_led_trigger_sysdev, msm_led_trigger_sysdev_attrs[i]); if (rc) { goto msm_led_trigger_register_sysdev_failed; } } msm_led_trigger_sysdev_fctrl = fctrl; return 0; msm_led_trigger_register_sysdev_failed: while (--i >= 0) sysdev_remove_file(&msm_led_trigger_sysdev, msm_led_trigger_sysdev_attrs[i]); sysdev_unregister(&msm_led_trigger_sysdev); sysdev_class_unregister(&msm_led_trigger_sysdev_class); return rc; }
/* * Sys device register * * sysdev file: * * /sys/devices/system/zte_ftm/zte_ftm0/fusion * /sys/devices/system/zte_ftm/zte_ftm0/simlocking */ static int32_t ftm_register_sysdev(struct sys_device *sysdev) { int32_t ret; int32_t i; ret = sysdev_class_register(&ftm_sysdev_class); if (ret) { return ret; } sysdev->id = 0; sysdev->cls = &ftm_sysdev_class; ret = sysdev_register(sysdev); if (ret) { sysdev_class_unregister(&ftm_sysdev_class); return ret; } for (i = 0; i < ARRAY_SIZE(ftm_attrs); i++) { ret = sysdev_create_file(sysdev, ftm_attrs[i]); if (ret) { goto ftm_fail; } } return 0; ftm_fail: while (--i >= 0) sysdev_remove_file(sysdev, ftm_attrs[i]); sysdev_unregister(sysdev); sysdev_class_unregister(&ftm_sysdev_class); return ret; }
static int __init register_balloon(struct sys_device *sysdev) { int i, error; error = sysdev_class_register(&balloon_sysdev_class); if (error) return error; sysdev->id = 0; sysdev->cls = &balloon_sysdev_class; error = sysdev_register(sysdev); if (error) { sysdev_class_unregister(&balloon_sysdev_class); return error; } for (i = 0; i < ARRAY_SIZE(balloon_attrs); i++) { error = sysdev_create_file(sysdev, balloon_attrs[i]); if (error) goto fail; } error = sysfs_create_group(&sysdev->kobj, &balloon_info_group); if (error) goto fail; return 0; fail: while (--i >= 0) sysdev_remove_file(sysdev, balloon_attrs[i]); sysdev_unregister(sysdev); sysdev_class_unregister(&balloon_sysdev_class); return error; }
/* * register_cpu - Setup a driverfs device for a CPU. * @cpu - Callers can set the cpu->no_control field to 1, to indicate not to * generate a control file in sysfs for this CPU. * @num - CPU number to use when creating the device. * * Initialize and register the CPU device. */ int __devinit register_cpu(struct cpu *cpu, int num, struct node *root) { int error; cpu->node_id = cpu_to_node(num); cpu->sysdev.id = num; cpu->sysdev.cls = &cpu_sysdev_class; error = sysdev_register(&cpu->sysdev); if (!error && root) error = sysfs_create_link(&root->sysdev.kobj, &cpu->sysdev.kobj, kobject_name(&cpu->sysdev.kobj)); if (!error && !cpu->no_control) register_cpu_control(cpu); if (!error) cpu_sys_devices[num] = &cpu->sysdev; #ifdef CONFIG_KEXEC if (!error) error = sysdev_create_file(&cpu->sysdev, &attr_crash_notes); #endif return error; }
static int __init topology_init(void) { int cpu; for_each_possible_cpu(cpu) { struct cpu *c = &per_cpu(cpu_devices, cpu); register_cpu(c, cpu); #ifdef CONFIG_PERFORMANCE_COUNTERS sysdev_create_file(&c->sysdev, &attr_pc0event); sysdev_create_file(&c->sysdev, &attr_pc0count); sysdev_create_file(&c->sysdev, &attr_pc1event); sysdev_create_file(&c->sysdev, &attr_pc1count); sysdev_create_file(&c->sysdev, &attr_pccycles); sysdev_create_file(&c->sysdev, &attr_pcenable); #endif } return 0; }
static int bq27541_battery_sysdev_ctrl_init(void) { int err = 0; err = sysdev_class_register(&bq27541_battery_sysclass); if (!err) err = sysdev_register(&bq27541_battery_device); if (!err) { sysdev_create_file(&bq27541_battery_device, &attr_battery_id); sysdev_create_file(&bq27541_battery_device, &attr_battery_current); sysdev_create_file(&bq27541_battery_device, &attr_battery_voltage); sysdev_create_file(&bq27541_battery_device, &attr_battery_temperature); sysdev_create_file(&bq27541_battery_device, &attr_battery_capacity); sysdev_create_file(&bq27541_battery_device, &attr_battery_mAH); sysdev_create_file(&bq27541_battery_device, &attr_battery_voltage_thresholds); sysdev_create_file(&bq27541_battery_device, &attr_battery_polling_intervals); sysdev_create_file(&bq27541_battery_device, &attr_battery_temp_thresholds); sysdev_create_file(&bq27541_battery_device, &attr_battery_i2c_address); sysdev_create_file(&bq27541_battery_device, &attr_battery_error); sysdev_create_file(&bq27541_battery_device, &attr_battery_suspend_current); sysdev_create_file(&bq27541_battery_device, &attr_battery_current_diags); sysdev_create_file(&bq27541_battery_device, &attr_battery_suspend_current_diags); sysdev_create_file(&bq27541_battery_device, &attr_battery_cycl); sysdev_create_file(&bq27541_battery_device, &attr_battery_lmd); sysdev_create_file(&bq27541_battery_device, &attr_battery_cyct); sysdev_create_file(&bq27541_battery_device, &attr_resume_stats); sysdev_create_file(&bq27541_battery_device, &attr_battreg); sysdev_create_file(&bq27541_battery_device, &attr_battreg_value); } return err; }
static int summit_smb347_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct summit_smb347_info *info; int ret = 0; #ifdef SUMMIT_SMB347_DEBUG int i = 0; #endif int error = 0; unsigned char value = 0xff; info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) { return -ENOMEM; } client->addr = SUMMIT_SMB347_I2C_ADDRESS; i2c_set_clientdata(client, info); info->client = client; info->charger.name = "summit_smb347"; info->charger.type = POWER_SUPPLY_TYPE_MAINS; info->charger.get_property = smb347_get_property; info->charger.properties = smb347_charger_props; info->charger.num_properties = ARRAY_SIZE(smb347_charger_props); ret = power_supply_register(&client->dev, &info->charger); if (ret) { dev_err(&client->dev, "failed: power supply register\n"); i2c_set_clientdata(client, NULL); kfree(info); return ret; } summit_smb347_i2c_client = info->client; summit_smb347_i2c_client->addr = SUMMIT_SMB347_I2C_ADDRESS; if (summit_smb347_read_id(&summit_smb347_id_reg) < 0) return -ENODEV; printk(KERN_INFO "Summit SMB347 detected, chip_id=0x%x\n", summit_smb347_id_reg); ret = request_irq(summit_smb347_i2c_client->irq, summit_smb347_irq, IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING, "summit_smb347", NULL); if (ret != 0) { printk(KERN_ERR "Failed to request IRQ %d: %d\n", summit_smb347_i2c_client->irq, ret); } summit_smb347_init_registers(); #ifdef SUMMIT_SMB347_DEBUG for (i = 0; i <= 0xE; i++) { ret = summit_smb347_i2c_read(i, &value); printk(KERN_INFO "summit_smb347: reg=%d, value=0x%x\n", i, value); } for (i = 0x30; i <= 0x3F; i++) { ret = summit_smb347_i2c_read(i, &value); printk(KERN_INFO "summit_smb347: reg=%d, value=0x%x\n", i, value); } #endif error = sysdev_class_register(&smb347_reg_sysclass); if (!error) error = sysdev_register(&device_smb347_reg); if (!error) error = sysdev_create_file(&device_smb347_reg, &attr_smb347_reg); error = sysdev_class_register(&smb347_register_sysclass); if (!error) error = sysdev_register(&device_smb347_register); if (!error) error = sysdev_create_file(&device_smb347_register, &attr_smb347_register); return 0; }
static void register_cpu_online(unsigned int cpu) { struct cpu *c = &per_cpu(cpu_devices, cpu); struct sys_device *s = &c->sysdev; #ifndef CONFIG_PPC_ISERIES if (cpu_has_feature(CPU_FTR_SMT)) sysdev_create_file(s, &attr_smt_snooze_delay); #endif /* PMC stuff */ sysdev_create_file(s, &attr_mmcr0); sysdev_create_file(s, &attr_mmcr1); if (cpu_has_feature(CPU_FTR_MMCRA)) sysdev_create_file(s, &attr_mmcra); if (cur_cpu_spec->num_pmcs >= 1) sysdev_create_file(s, &attr_pmc1); if (cur_cpu_spec->num_pmcs >= 2) sysdev_create_file(s, &attr_pmc2); if (cur_cpu_spec->num_pmcs >= 3) sysdev_create_file(s, &attr_pmc3); if (cur_cpu_spec->num_pmcs >= 4) sysdev_create_file(s, &attr_pmc4); if (cur_cpu_spec->num_pmcs >= 5) sysdev_create_file(s, &attr_pmc5); if (cur_cpu_spec->num_pmcs >= 6) sysdev_create_file(s, &attr_pmc6); if (cur_cpu_spec->num_pmcs >= 7) sysdev_create_file(s, &attr_pmc7); if (cur_cpu_spec->num_pmcs >= 8) sysdev_create_file(s, &attr_pmc8); if (cpu_has_feature(CPU_FTR_SMT)) sysdev_create_file(s, &attr_purr); }
static void __cpuinit register_cpu_control(struct cpu *cpu) { sysdev_create_file(&cpu->sysdev, &attr_online); }