static int create_efivars_bin_attributes(void) { struct bin_attribute *attr; int error; /* new_var */ attr = kzalloc(sizeof(*attr), GFP_KERNEL); if (!attr) return -ENOMEM; attr->attr.name = "new_var"; attr->attr.mode = 0200; attr->write = efivar_create; efivars_new_var = attr; /* del_var */ attr = kzalloc(sizeof(*attr), GFP_KERNEL); if (!attr) { error = -ENOMEM; goto out_free; } attr->attr.name = "del_var"; attr->attr.mode = 0200; attr->write = efivar_delete; efivars_del_var = attr; sysfs_bin_attr_init(efivars_new_var); sysfs_bin_attr_init(efivars_del_var); /* Register */ error = sysfs_create_bin_file(&efivars_kset->kobj, efivars_new_var); if (error) { printk(KERN_ERR "efivars: unable to create new_var sysfs file" " due to error %d\n", error); goto out_free; } error = sysfs_create_bin_file(&efivars_kset->kobj, efivars_del_var); if (error) { printk(KERN_ERR "efivars: unable to create del_var sysfs file" " due to error %d\n", error); sysfs_remove_bin_file(&efivars_kset->kobj, efivars_new_var); goto out_free; } return 0; out_free: kfree(efivars_del_var); efivars_del_var = NULL; kfree(efivars_new_var); efivars_new_var = NULL; return error; }
static int __init create_sysfs_entries(void) { int err = 0; #define create_cpu_attr(name) \ if (!err) \ err = device_create_file(cpu_subsys.dev_root, &dev_attr_##name); create_cpu_attr(chip_width); create_cpu_attr(chip_height); create_cpu_attr(chip_serial); create_cpu_attr(chip_revision); #define create_hv_attr(name) \ if (!err) \ err = sysfs_create_file(hypervisor_kobj, &dev_attr_##name.attr); create_hv_attr(type); create_hv_attr(version); create_hv_attr(config_version); if (!err) err = sysfs_create_group(hypervisor_kobj, &board_attr_group); if (!err) { sysfs_bin_attr_init(&hvconfig_bin); hvconfig_bin.attr.name = "hvconfig"; hvconfig_bin.attr.mode = S_IRUGO; hvconfig_bin.read = hvconfig_bin_read; hvconfig_bin.size = PAGE_SIZE; err = sysfs_create_bin_file(hypervisor_kobj, &hvconfig_bin); } return err; }
static int watch_fontdata_attr_init(struct lg4945_data *d) { d->watch.font_written_size = 0; d->watch.font_width = 0; d->watch.font_written_comp_size = COMP_FONTM_MAX_SIZE; d->watch.fontdata_size = MAX_WATCH_DATA_SIZE; d->watch.fontdata_comp_size = COMP_FONTM_MAX_SIZE; d->watch.ext_wdata.font_data = kzalloc(d->watch.fontdata_size, GFP_KERNEL); d->watch.ext_wdata.comp_buf = kzalloc(d->watch.fontdata_comp_size, GFP_KERNEL); if (d->watch.ext_wdata.font_data && d->watch.ext_wdata.comp_buf) { TOUCH_I("%s font_buffer(%d KB) malloc\n", __func__, d->watch.fontdata_size/1024); } else { TOUCH_E("%s font_buffer(%d KB) malloc failed\n", __func__, d->watch.fontdata_size/1024); return 1; } sysfs_bin_attr_init(&d->watch.fontdata_attr); d->watch.fontdata_attr.attr.name = "config_fontdata"; d->watch.fontdata_attr.attr.mode = S_IWUSR | S_IRUSR; d->watch.fontdata_attr.read = watch_access_read; d->watch.fontdata_attr.write = watch_access_write; d->watch.fontdata_attr.size = d->watch.fontdata_size; if (sysfs_create_bin_file(&d->kobj, &d->watch.fontdata_attr) < 0) TOUCH_E("Failed to create %s\n", d->watch.fontdata_attr.attr.name); return 0; }
static int ds1742_rtc_probe(struct platform_device *pdev) { struct rtc_device *rtc; struct resource *res; unsigned int cen, sec; struct rtc_plat_data *pdata; void __iomem *ioaddr; int ret = 0; pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); ioaddr = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(ioaddr)) return PTR_ERR(ioaddr); pdata->ioaddr_nvram = ioaddr; pdata->size_nvram = resource_size(res) - RTC_SIZE; pdata->ioaddr_rtc = ioaddr + pdata->size_nvram; sysfs_bin_attr_init(&pdata->nvram_attr); pdata->nvram_attr.attr.name = "nvram"; pdata->nvram_attr.attr.mode = S_IRUGO | S_IWUSR; pdata->nvram_attr.read = ds1742_nvram_read; pdata->nvram_attr.write = ds1742_nvram_write; pdata->nvram_attr.size = pdata->size_nvram; /* turn RTC on if it was not on */ ioaddr = pdata->ioaddr_rtc; sec = readb(ioaddr + RTC_SECONDS); if (sec & RTC_STOP) { sec &= RTC_SECONDS_MASK; cen = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK; writeb(RTC_WRITE, ioaddr + RTC_CONTROL); writeb(sec, ioaddr + RTC_SECONDS); writeb(cen & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL); } if (!(readb(ioaddr + RTC_DAY) & RTC_BATT_FLAG)) dev_warn(&pdev->dev, "voltage-low detected.\n"); pdata->last_jiffies = jiffies; platform_set_drvdata(pdev, pdata); rtc = devm_rtc_device_register(&pdev->dev, pdev->name, &ds1742_rtc_ops, THIS_MODULE); if (IS_ERR(rtc)) return PTR_ERR(rtc); ret = sysfs_create_bin_file(&pdev->dev.kobj, &pdata->nvram_attr); if (ret) dev_err(&pdev->dev, "Unable to create sysfs entry: %s\n", pdata->nvram_attr.attr.name); return 0; }
static int __init rp5c01_rtc_probe(struct platform_device *dev) { struct resource *res; struct rp5c01_priv *priv; struct rtc_device *rtc; int error; res = platform_get_resource(dev, IORESOURCE_MEM, 0); if (!res) return -ENODEV; priv = kzalloc(sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->regs = ioremap(res->start, resource_size(res)); if (!priv->regs) { error = -ENOMEM; goto out_free_priv; } sysfs_bin_attr_init(&priv->nvram_attr); priv->nvram_attr.attr.name = "nvram"; priv->nvram_attr.attr.mode = S_IRUGO | S_IWUSR; priv->nvram_attr.read = rp5c01_nvram_read; priv->nvram_attr.write = rp5c01_nvram_write; priv->nvram_attr.size = RP5C01_MODE; spin_lock_init(&priv->lock); rtc = rtc_device_register("rtc-rp5c01", &dev->dev, &rp5c01_rtc_ops, THIS_MODULE); if (IS_ERR(rtc)) { error = PTR_ERR(rtc); goto out_unmap; } priv->rtc = rtc; platform_set_drvdata(dev, priv); error = sysfs_create_bin_file(&dev->dev.kobj, &priv->nvram_attr); if (error) goto out_unregister; return 0; out_unregister: rtc_device_unregister(rtc); out_unmap: iounmap(priv->regs); out_free_priv: kfree(priv); return error; }
static struct elog_obj *create_elog_obj(uint64_t id, size_t size, uint64_t type) { struct elog_obj *elog; int rc; elog = kzalloc(sizeof(*elog), GFP_KERNEL); if (!elog) return NULL; elog->kobj.kset = elog_kset; kobject_init(&elog->kobj, &elog_ktype); sysfs_bin_attr_init(&elog->raw_attr); elog->raw_attr.attr.name = "raw"; elog->raw_attr.attr.mode = 0400; elog->raw_attr.size = size; elog->raw_attr.read = raw_attr_read; elog->id = id; elog->size = size; elog->type = type; elog->buffer = kzalloc(elog->size, GFP_KERNEL); if (elog->buffer) { rc = opal_read_elog(__pa(elog->buffer), elog->size, elog->id); if (rc != OPAL_SUCCESS) { pr_err("ELOG: log read failed for log-id=%llx\n", elog->id); kfree(elog->buffer); elog->buffer = NULL; } } rc = kobject_add(&elog->kobj, NULL, "0x%llx", id); if (rc) { kobject_put(&elog->kobj); return NULL; } rc = sysfs_create_bin_file(&elog->kobj, &elog->raw_attr); if (rc) { kobject_put(&elog->kobj); return NULL; } kobject_uevent(&elog->kobj, KOBJ_ADD); return elog; }
static int __init create_sysfs_entries(void) { int err = 0; #define create_cpu_attr(name) \ if (!err) \ err = device_create_file(cpu_subsys.dev_root, &dev_attr_##name); create_cpu_attr(chip_width); create_cpu_attr(chip_height); create_cpu_attr(chip_serial); create_cpu_attr(chip_revision); #define create_hv_attr(name) \ if (!err) \ err = sysfs_create_file(hypervisor_kobj, &dev_attr_##name.attr); create_hv_attr(type); create_hv_attr(version); create_hv_attr(config_version); if (!err) err = sysfs_create_group(hypervisor_kobj, &board_attr_group); if (!err) { sysfs_bin_attr_init(&hvconfig_bin); hvconfig_bin.attr.name = "hvconfig"; hvconfig_bin.attr.mode = S_IRUGO; hvconfig_bin.read = hvconfig_bin_read; hvconfig_bin.size = PAGE_SIZE; err = sysfs_create_bin_file(hypervisor_kobj, &hvconfig_bin); } if (!err) { /* * Don't bother adding the hv_stats files on each CPU if * our hypervisor doesn't supply statistics. */ int cpu = raw_smp_processor_id(); long lotar = HV_XY_TO_LOTAR(cpu_x(cpu), cpu_y(cpu)); char dummy; ssize_t n = hv_confstr(HV_CONFSTR_HV_STATS, (unsigned long) &dummy, 1, lotar, 0); if (n >= 0) err = subsys_interface_register(&hv_stats_interface); } return err; }
static struct dump_obj *create_dump_obj(uint32_t id, size_t size, uint32_t type) { struct dump_obj *dump; int rc; dump = kzalloc(sizeof(*dump), GFP_KERNEL); if (!dump) return NULL; dump->kobj.kset = dump_kset; kobject_init(&dump->kobj, &dump_ktype); sysfs_bin_attr_init(&dump->dump_attr); dump->dump_attr.attr.name = "dump"; dump->dump_attr.attr.mode = 0400; dump->dump_attr.size = size; dump->dump_attr.read = dump_attr_read; dump->id = id; dump->size = size; dump->type = type; rc = kobject_add(&dump->kobj, NULL, "0x%x-0x%x", type, id); if (rc) { kobject_put(&dump->kobj); return NULL; } rc = sysfs_create_bin_file(&dump->kobj, &dump->dump_attr); if (rc) { kobject_put(&dump->kobj); return NULL; } pr_info("%s: New platform dump. ID = 0x%x Size %u\n", __func__, dump->id, dump->size); kobject_uevent(&dump->kobj, KOBJ_ADD); return dump; }