/*
* initialise the fs caching module
*/
static int __init fscache_init(void)
{
int ret;
ret = slow_work_register_user(THIS_MODULE);
if (ret < 0)
goto error_slow_work;
ret = fscache_proc_init();
if (ret < 0)
goto error_proc;
fscache_cookie_jar = kmem_cache_create("fscache_cookie_jar",
sizeof(struct fscache_cookie),
0,
0,
fscache_cookie_init_once);
if (!fscache_cookie_jar) {
printk(KERN_NOTICE
"FS-Cache: Failed to allocate a cookie jar\n");
ret = -ENOMEM;
goto error_cookie_jar;
}
fscache_root = kobject_create_and_add("fscache", kernel_kobj);
if (!fscache_root)
goto error_kobj;
printk(KERN_NOTICE "FS-Cache: Loaded\n");
return 0;
error_kobj:
kmem_cache_destroy(fscache_cookie_jar);
error_cookie_jar:
fscache_proc_cleanup();
error_proc:
slow_work_unregister_user(THIS_MODULE);
error_slow_work:
return ret;
}
int logger_mode_init(void)
{
int logger_mode_retval;
logger_mode_kobj = kobject_create_and_add("logger_mode", kernel_kobj);
if (!logger_mode_kobj) {
return -ENOMEM;
}
logger_mode_retval = sysfs_create_group(logger_mode_kobj, &logger_mode_attr_group);
if (logger_mode_retval)
{
kobject_put(logger_mode_kobj);
}
// initialize logger mode to 0 (disabled) as default
logger_mode = 0;
return (logger_mode_retval);
}
int printk_mode_init(void)
{
int printk_mode_retval;
printk_mode_kobj = kobject_create_and_add("printk_mode", kernel_kobj);
if (!printk_mode_kobj) {
return -ENOMEM;
}
printk_mode_retval = sysfs_create_group(printk_mode_kobj, &printk_mode_attr_group);
if (printk_mode_retval)
{
kobject_put(printk_mode_kobj);
}
// initialize printk mode to 1 (enabled) as default
printk_mode = 1;
return (printk_mode_retval);
}
/**
* tp_get_touch_screen_obj - it is a common function,tp can call it to creat /sys/touch_screen file node
*
* @no input value
*
* This function is tp call it to creat /sys/touch_screen file node.
*
* The kobject of touch_screen_kobject_ts will be returned,notice it is static.
*/
struct kobject* tp_get_touch_screen_obj(void)
{
if( NULL == touch_screen_kobject_ts )
{
touch_screen_kobject_ts = kobject_create_and_add("touch_screen", NULL);
if (!touch_screen_kobject_ts)
{
tp_log_err("%s: create touch_screen kobjetct error!\n", __func__);
return NULL;
}
else
{
tp_log_debug("%s: create sys/touch_screen successful!\n", __func__);
}
}
else
{
tp_log_debug("%s: sys/touch_screen already exist!\n", __func__);
}
return touch_screen_kobject_ts;
}
/**
* tp_get_virtual_key_obj - it is a common function,tp can call it to creat virtual_key file node in /sys/
*
* @no input value
*
* This function is tp call it to creat virtual_key file node in /sys/
*
* The kobject of virtual_key_kobject_ts will be returned
*/
struct kobject* tp_get_virtual_key_obj(char *name)
{
if( NULL == virtual_key_kobject_ts )
{
virtual_key_kobject_ts = kobject_create_and_add(name, NULL);
if (!virtual_key_kobject_ts)
{
tp_log_err("%s: create virtual_key kobjetct error!\n", __func__);
return NULL;
}
else
{
tp_log_debug("%s: create virtual_key successful!\n", __func__);
}
}
else
{
tp_log_debug("%s: virtual_key already exist!\n", __func__);
}
return virtual_key_kobject_ts;
}
static int charger_control_probe(void)
{
int sysfs_result;
printk(KERN_DEBUG "[%s]\n",__func__);
charger_control_kobj = kobject_create_and_add("thundercharge_control", kernel_kobj);
if (!charger_control_kobj) {
pr_err("%s Interface create failed!\n",
__FUNCTION__);
return -ENOMEM;
}
sysfs_result = sysfs_create_group(charger_control_kobj,
&chgr_control_attr_group);
if (sysfs_result) {
pr_info("%s sysfs create failed!\n", __FUNCTION__);
kobject_put(charger_control_kobj);
}
return sysfs_result;
}
static int imx219_sysfs_init(void)
{
int ret ;
pr_info("%s: imx219:kobject creat and add\n", __func__);
android_imx219 = kobject_create_and_add("android_camera", NULL);
if (android_imx219 == NULL) {
pr_info("imx219_sysfs_init: subsystem_register " \
"failed\n");
ret = -ENOMEM;
return ret ;
}
pr_info("imx219:sysfs_create_file\n");
ret = sysfs_create_file(android_imx219, &dev_attr_sensor.attr);
if (ret) {
pr_info("imx219_sysfs_init: sysfs_create_file " \
"failed\n");
kobject_del(android_imx219);
}
return 0 ;
}
int ntrig_dispathcer_sysfs_init(void)
{
int retval;
ntrig_dbg( "inside %s\n", __FUNCTION__);
dispatcher_kobj = kobject_create_and_add("ntrig", NULL);
if (!dispatcher_kobj) {
ntrig_dbg( "inside %s\n failed to create dispatcher_kobj", __FUNCTION__);
return -ENOMEM;
}
/* Create the files associated with this kobject */
retval = sysfs_create_group(dispatcher_kobj, &attr_group);
if (retval) {
ntrig_dbg( "inside %s\n failed to create sysfs_group", __FUNCTION__);
kobject_put(dispatcher_kobj);
}
#ifdef VIRTUAL_KEYS_SUPPORTED
ntrig_create_virtualkeys_file();
#endif
ntrig_dbg("ntrig-dispatcher-sysfs inside %s \n", __FUNCTION__);
if(setup_config_dispatcher(&read_config_dispatcher, &write_config_dispatcher)){
ntrig_dbg("ntrig-dispatcher-sysfs inside %s cannot setup_get_bus_interface\n", __FUNCTION__);
}
if(setup_config_sensor(&read_config_sensor, &write_config_sensor)){
ntrig_dbg("ntrig-dispatcher-sysfs inside %s cannot setup_config_sensor\n", __FUNCTION__);
}
if(setup_get_bus_interface(&read_get_bus_interface, &write_get_bus_interface)){
ntrig_dbg("ntrig-dispatcher-sysfs inside %s cannot setup_get_bus_interface\n", __FUNCTION__);
}
if(setup_config_counters(&read_get_counters, &write_reset_counters)){
ntrig_dbg("ntrig-dispatcher-sysfs inside %s cannot setup_get_counters\n", __FUNCTION__);
}
return retval;
}
static int __init mntest_init(void)
{
int ret;
#ifdef SYSFS_ATTR_CREATE
/*
* Create a simple kobject with the name of "mntest",
* located under /sys/kernel/
**/
mntest_kobj = kobject_create_and_add("mntest", kernel_kobj);
if (!mntest_kobj)
return -ENOMEM;
ret = sysfs_create_file(mntest_kobj, &test_value_attribute);
if (ret)
kobject_put(mntest_kobj);
#endif
printk("%s:%d\n", __func__, __LINE__);
return ret;
}
static int add_sysfs_objects(struct sleep_data *sleep_info)
{
int err = 0;
atomic_set(&sleep_info->timer_expired, 0);
atomic_set(&sleep_info->timer_val_ms, INT_MAX);
sleep_info->attr_group = &sleep_info_attr_group;
sleep_info->kobj = kobject_create_and_add("sleep-stats",
&get_cpu_device(0)->kobj);
if (!sleep_info->kobj)
return -ENOMEM;
err = sysfs_create_group(sleep_info->kobj, sleep_info->attr_group);
if (err)
kobject_put(sleep_info->kobj);
else
kobject_uevent(sleep_info->kobj, KOBJ_ADD);
return err;
}
static int __init pm_init(void)
{
int error = pm_start_workqueue();
#ifdef CONFIG_PERFLOCK
int i;
static char ceil_buf[PERF_LOCK_INVALID][38];
static char perf_buf[PERF_LOCK_INVALID][24];
#endif
if (error)
return error;
hibernate_image_size_init();
hibernate_reserved_size_init();
touch_evt_timer_val = ktime_set(2, 0);
hrtimer_init(&tc_ev_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
tc_ev_timer.function = &tc_ev_stop;
tc_ev_processed = 1;
power_kobj = kobject_create_and_add("power", NULL);
#ifdef CONFIG_PERFLOCK
perf_lock_init(&user_cpu_perf_lock, TYPE_PERF_LOCK, PERF_LOCK_HIGHEST, "User CPU Highest Perflock");
perf_lock_init(&user_cpu_ceiling_lock, TYPE_CPUFREQ_CEILING, PERF_LOCK_HIGH, "User CPU High cpufreq_ceiling lock");
for (i = PERF_LOCK_LOWEST; i < PERF_LOCK_INVALID; i++) {
snprintf(perf_buf[i], 23, "User Perflock level(%d)", i);
perf_buf[i][23] = '\0';
perf_lock_init(&user_perf_lock[i], TYPE_PERF_LOCK, i, perf_buf[i]);
snprintf(ceil_buf[i], 37, "User cpufreq_ceiling lock level(%d)", i);
ceil_buf[i][37] = '\0';
perf_lock_init(&user_ceiling_lock[i], TYPE_CPUFREQ_CEILING, i, ceil_buf[i]);
}
#endif
if (!power_kobj)
return -ENOMEM;
error = sysfs_create_group(power_kobj, &attr_group);
if (error)
return error;
return pm_autosleep_init();
}
static int __init sysfscluster_init(void)
{
int e;
TRACE_CLUSTER(("+sysfscluster_init\n"));
if (!cluster_switch_supported()) {
pr_info("%s: Cluster switch disabled\n", __func__);
return 0;
}
spin_lock_init(&cluster_lock);
cluster_kobj = kobject_create_and_add("cluster", kernel_kobj);
CREATE_FILE(active);
CREATE_FILE(immediate);
CREATE_FILE(force);
CREATE_FILE(wake_ms);
#if defined(CONFIG_PM_SLEEP) && SYSFS_CLUSTER_POWER_MODE
CREATE_FILE(powermode);
#endif
#ifdef CONFIG_ARCH_TEGRA_HAS_SYMMETRIC_CPU_PWR_GATE
CREATE_FILE(powergate);
#endif
#if DEBUG_CLUSTER_SWITCH
CREATE_FILE(debug);
#endif
spin_lock(&cluster_lock);
if (is_lp_cluster())
flags |= TEGRA_POWER_CLUSTER_LP;
else
flags |= TEGRA_POWER_CLUSTER_G;
spin_unlock(&cluster_lock);
fail:
TRACE_CLUSTER(("-sysfscluster_init\n"));
return e;
}
static int __init enhance_init(void)
{
int retval;
int attr_count = 0;
enhance__kobj = kobject_create_and_add("lcd_enhance", kernel_kobj);
if (!enhance__kobj)
return -ENOMEM;
/* Create the files associated with this kobject */
for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) {
if(!zte_enhance_val.en_colortmp && (attr_count == 1))
continue;
retval = sysfs_create_file(enhance__kobj, &attrs[attr_count].attr);
if (retval < 0) {
pr_err("%s: Failed to create sysfs attributes\n", __func__);
goto err_sys;
}
}
pr_info("lcd: %s Done.\n",__func__);
return retval;
err_sys:
for (attr_count--; attr_count >= 0; attr_count--) {
sysfs_remove_file(enhance__kobj, &attrs[attr_count].attr);
}
kobject_put(enhance__kobj);
pr_info("lcd: %s init ERR.\n",__func__);
return retval;
}
int init_module(void)
{
int ret;
ProcBuffer = vmalloc(sizeof(char)*MAXDATASIZE);
if(ProcBuffer == NULL) {
return -ENOMEM;
}
memset(ProcBuffer,0,sizeof(char)*MAXDATASIZE);
WritingLength = 0;
/* Procfs setting */
/*
if( (proc_mtd = create_proc_entry("htc_monitor", 0444, NULL)) ) {
proc_mtd->proc_fops = &log_proc_ops;
}
*/
proc_mtd = proc_create_data("htc_monitor", 0444, NULL, &log_proc_ops, NULL);
if (proc_mtd == NULL) {
pr_info("proc_create_data is null\n");
}
/* Attribute file setting */
htc_monitor_status_obj = kobject_create_and_add("htc_monitor_status", NULL);
if (htc_monitor_status_obj == NULL) {
pr_info("kobject_create_and_add: htc_monitor_status failed\n");
return -EFAULT;
}
ret = sysfs_create_file(htc_monitor_status_obj,
&dev_attr_htc_monitor_param.attr);
if (ret) {
pr_info("sysfs_create_file: dev_attr_htc_monitor_param failed\n");
return -EFAULT;
}
return 0;
}
int __init shuttle_usb_register_devices(void)
{
#ifdef CONFIG_USB_SUPPORT
int ret;
tegra_ehci1_device.dev.platform_data = &tegra_ehci_pdata[0];
tegra_ehci3_device.dev.platform_data = &tegra_ehci_pdata[1];
#ifdef CONFIG_USB_TEGRA_OTG
tegra_otg_device.dev.platform_data = &tegra_otg_pdata;
#endif
/* If in host mode, set VBUS to 1 */
gpio_request(SHUTTLE_USB0_VBUS, "USB0 VBUS"); /* VBUS switch, perhaps ? -- Tied to what? -- should require +5v ... */
/* 0 = Gadget */
gpio_direction_output(SHUTTLE_USB0_VBUS, 0 ); /* Gadget */
ret = platform_add_devices(shuttle_usb_devices, ARRAY_SIZE(shuttle_usb_devices));
if (ret)
return ret;
/* Enable gadget mode by default */
tegra_set_gadget_mode();
/* Register a sysfs interface to let user switch modes */
usb_kobj = kobject_create_and_add("usbbus", NULL);
if (!usb_kobj) {
pr_err("Unable to register USB mode switch");
return 0;
}
/* Attach an attribute to the already registered usbbus to let the user switch usb modes */
return sysfs_create_group(usb_kobj, &usb_attr_group);
#else
return 0;
#endif
}
static int create_test_nodes(int size, struct kobject *parent_kobj)
{
int i, j;
int retval = 0;
char *name;
//struct attribute *temp_attr;
//char test_mode[][DEVNAME_SIZE] = {"DATA_READ", "DATA_WRITE", "CMD"};
//int test_mode_count = sizeof(test_mode)/sizeof(test_mode[0]);
test_attrs = kzalloc(TEST_MODE_COUNT * size * sizeof(struct attribute*), GFP_KERNEL);
test_kattr = kzalloc(TEST_MODE_COUNT * size * sizeof(struct kobj_attribute*), GFP_KERNEL);
tmode_kobj = kzalloc(size * sizeof(struct kobject*), GFP_KERNEL);
for(i=0; i<size; i++){
name = kzalloc(DEVNAME_SIZE, GFP_KERNEL);
sprintf(name, "%d", i);
tmode_kobj[i] = kobject_create_and_add(name, parent_kobj);
if (tmode_kobj[i] == NULL)
return -ENOMEM;
for(j=0; j<TEST_MODE_COUNT; j++){
test_attrs[i*TEST_MODE_COUNT+j] = kzalloc(sizeof(struct attribute), GFP_KERNEL);
test_kattr[i*TEST_MODE_COUNT+j] = kzalloc(sizeof(struct kobj_attribute), GFP_KERNEL);
name = kzalloc(DEVNAME_SIZE, GFP_KERNEL);
sprintf(name, "%s", test_mode[j]);
test_attrs[i*TEST_MODE_COUNT+j]->name = name;
test_attrs[i*TEST_MODE_COUNT+j]->mode = 0777;
test_kattr[i*TEST_MODE_COUNT+j]->attr = *test_attrs[i*TEST_MODE_COUNT+j];//*temp_attr;
test_kattr[i*TEST_MODE_COUNT+j]->show = test_show;
test_kattr[i*TEST_MODE_COUNT+j]->store = test_store;
//test_attrs[i*TEST_MODE_COUNT+j] = &test_kattr[i*TEST_MODE_COUNT+j]->attr;
retval = sysfs_create_file(tmode_kobj[i], &test_kattr[i*TEST_MODE_COUNT+j]->attr);
if (retval)
kobject_put(tmode_kobj[i]);
}
}
return 0;
}
//#ifdef CONFIG_AMAZON_POWER_DEBUG
//extern int init_wakeup_monitor(struct kobject*);
//#endif
static int __init pm_init(void)
{
int error = pm_start_workqueue();
if (error)
return error;
hibernate_image_size_init();
hibernate_reserved_size_init();
touch_evt_timer_val = ktime_set(2, 0);
hrtimer_init(&tc_ev_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
tc_ev_timer.function = &tc_ev_stop;
tc_ev_processed = 1;
power_kobj = kobject_create_and_add("power", NULL);
if (!power_kobj)
return -ENOMEM;
error = sysfs_create_group(power_kobj, &attr_group);
if (error)
return error;
return pm_autosleep_init();
}
static int ts_key_report_init(void)
{
int ret;
pr_info("%s called!\n", __func__);
virtual_key_kobj = kobject_get(android_touch_kobj);
if (virtual_key_kobj == NULL) {
virtual_key_kobj = kobject_create_and_add("board_properties", NULL);
if (virtual_key_kobj == NULL) {
pr_info(KERN_ERR "%s: subsystem_register failed\n", __func__);
ret = -ENOMEM;
return ret;
}
}
ret = sysfs_create_file(virtual_key_kobj, &dev_attr_virtualkeys.attr);
if (ret) {
pr_info(KERN_ERR "%s: sysfs_create_file failed\n", __func__);
return ret;
}
return 0;
}
static int fluid_board_props_init(void)
{
int rc;
struct kobject *properties_kobj;
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (!properties_kobj) {
rc = -ENOMEM;
goto err_kobj_create;
}
rc = sysfs_create_group(properties_kobj, &fluid_properties_attr_group);
if (rc)
goto err_sysfs_create;
return 0;
err_sysfs_create:
kobject_put(properties_kobj);
err_kobj_create:
pr_err("failed to create board_properties\n");
return rc;
}
static int __init sysfs_lkm_sysfs_init(void)
{
int ret;
pr_debug("%s: Init\n", DRV_NAME);
sysfs_lkm_kobject = kobject_create_and_add(SYSFS_NAME, kernel_kobj);
if (!sysfs_lkm_kobject) {
pr_debug("Failed to create kobject for %s\n", SYSFS_NAME);
return -ENOMEM;
}
/* Files go online as soon they are created */
init_rwsem(&rw_sem);
ret = sysfs_create_group(sysfs_lkm_kobject, &attr_group);
if (ret) {
kobject_put(sysfs_lkm_kobject);
return ret;
}
return 0;
}
static int __init compbench_init(void)
{
int retval;
cb_kobj = kobject_create_and_add("compbench", kernel_kobj);
if (!cb_kobj)
return -ENOMEM;
retval = sysfs_create_group(cb_kobj, &attr_group);
if (retval)
goto err;
retval = sysfs_create_bin_file(cb_kobj, &bin_attr_in);
if (retval)
goto err;
goto success;
err:
kobject_put(cb_kobj);
success:
return retval;
}
static int __init gpu_control_init(void)
{
int ret;
register_early_suspend(&gpu_control_suspend_handler);
gpu_control_kobj = kobject_create_and_add("gpu_control", kernel_kobj);
if (!gpu_control_kobj) {
pr_err("%s gpu_control kobject create failed!\n", __FUNCTION__);
return -ENOMEM;
}
ret = sysfs_create_group(gpu_control_kobj,
&gpu_control_group);
if (ret) {
pr_info("%s gpu_control sysfs create failed!\n", __FUNCTION__);
kobject_put(gpu_control_kobj);
}
init_gpu_proc_fs();
return ret;
}
static int vibr_level_control_init(void)
{
int sysfs_result;
printk(KERN_DEBUG "[%s]\n",__func__);
vibr_level_control_kobj =
kobject_create_and_add("thunderquake_engine", kernel_kobj);
if (!vibr_level_control_kobj) {
pr_err("%s Interface create failed!\n",
__FUNCTION__);
return -ENOMEM;
}
sysfs_result = sysfs_create_group(vibr_level_control_kobj,
&vibr_level_control_attr_group);
if (sysfs_result) {
pr_info("%s sysfs create failed!\n", __FUNCTION__);
kobject_put(vibr_level_control_kobj);
}
return sysfs_result;
}
static int cap_ts_vkeys_init(void)
{
int rc,i;
struct kobject * cap_ts_properties_kobj=NULL;
cap_ts_properties_kobj = kobject_create_and_add("board_properties", NULL);
if (cap_ts_properties_kobj == NULL) {
printk("%s: subsystem_register failed\n", __func__);
rc = -ENOMEM;
return rc;
}
android_touch_kobj = cap_ts_properties_kobj;
for ( i=0; i < ARRAY_SIZE(cap_ts_device_attr); i++ ){
rc = sysfs_create_file(cap_ts_properties_kobj, &cap_ts_device_attr[i].attr);
if (rc) {
printk("%s: sysfs_create_file failed\n", __func__);
return rc;
}
}
return 0;
}
/* Initializes the sysfs parameter
* registers the pm_event notifier
*/
int __init wakeup_reason_init(void)
{
int retval;
spin_lock_init(&resume_reason_lock);
retval = register_pm_notifier(&wakeup_reason_pm_notifier_block);
if (retval)
printk(KERN_WARNING "[%s] failed to register PM notifier %d\n",
__func__, retval);
wakeup_reason = kobject_create_and_add("wakeup_reasons", kernel_kobj);
if (!wakeup_reason) {
printk(KERN_WARNING "[%s] failed to create a sysfs kobject\n",
__func__);
return 1;
}
retval = sysfs_create_group(wakeup_reason, &attr_group);
if (retval) {
kobject_put(wakeup_reason);
printk(KERN_WARNING "[%s] failed to create a sysfs group %d\n",
__func__, retval);
}
return 0;
}
void __init acer_ts_init(void)
{
int ret = 0;
struct kobject *properties_kobj;
acer_smem_flag_t *acer_smem_flag;
acer_smem_flag = (acer_smem_flag_t *)(smem_alloc(SMEM_ID_VENDOR0, sizeof(acer_smem_flag_t)));
if (acer_smem_flag != NULL && acer_smem_flag->acer_hw_version < ACER_HW_VERSION_PVT)
a4_ts_board_info[0].irq = MSM_GPIO_TO_INT(A4_GPIO_CYP_TP_IRQ1);
else
a4_ts_board_info[0].irq = MSM_GPIO_TO_INT(A4_GPIO_CYP_TP_IRQ2);
i2c_register_board_info(0, a4_ts_board_info,
ARRAY_SIZE(a4_ts_board_info));
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
ret = sysfs_create_group(properties_kobj,
&a4_properties_attr_group);
if (!properties_kobj || ret)
pr_err("failed to create board_properties\n");
}
static int __init pnpmgr_init(void)
{
int ret;
init_timer(&app_timer);
app_timer.function = app_timeout_handler;
pnpmgr_kobj = kobject_create_and_add("pnpmgr", power_kobj);
if (!pnpmgr_kobj) {
pr_err("%s: Can not allocate enough memory for pnpmgr.\n", __func__);
return -ENOMEM;
}
cpufreq_kobj = kobject_create_and_add("cpufreq", pnpmgr_kobj);
hotplug_kobj = kobject_create_and_add("hotplug", pnpmgr_kobj);
thermal_kobj = kobject_create_and_add("thermal", pnpmgr_kobj);
apps_kobj = kobject_create_and_add("apps", pnpmgr_kobj);
battery_kobj = kobject_create_and_add("battery", pnpmgr_kobj);
adaptive_policy_kobj = kobject_create_and_add("adaptive_policy", power_kobj);
if (!cpufreq_kobj || !hotplug_kobj || !thermal_kobj || !apps_kobj || !battery_kobj || !adaptive_policy_kobj) {
pr_err("%s: Can not allocate enough memory.\n", __func__);
return -ENOMEM;
}
ret = sysfs_create_group(cpufreq_kobj, &cpufreq_attr_group);
ret |= sysfs_create_group(hotplug_kobj, &hotplug_attr_group);
ret |= sysfs_create_group(thermal_kobj, &thermal_attr_group);
ret |= sysfs_create_group(apps_kobj, &apps_attr_group);
ret |= sysfs_create_group(battery_kobj, &battery_attr_group);
ret |= sysfs_create_group(adaptive_policy_kobj, &adaptive_attr_group);
if (ret) {
pr_err("%s: sysfs_create_group failed\n", __func__);
return ret;
}
return 0;
}
static int hall_cover_sysfs_init(void)
{
int ret = 0;
android_cover_kobj = kobject_create_and_add("android_cover", NULL);
if (android_cover_kobj == NULL) {
HL_ERR("%s:subsystem_register_failed", __func__);
ret = -ENOMEM;
return ret;
}
ret = sysfs_create_file(android_cover_kobj, &dev_attr_debug_level.attr);
if (ret) {
HL_ERR("%s: sysfs_create_file debug_level failed\n", __func__);
return ret;
}
ret = sysfs_create_file(android_cover_kobj, &dev_attr_read_att.attr);
if (ret) {
HL_ERR("%s: sysfs_create_file read_att failed\n", __func__);
return ret;
}
HL_LOG("attribute file register Done");
return 0;
}
static int __init edac_init_mce_inject(void)
{
struct sysdev_class *edac_class = NULL;
int i, err = 0;
edac_class = edac_get_sysfs_class();
if (!edac_class)
return -EINVAL;
mce_kobj = kobject_create_and_add("mce", &edac_class->kset.kobj);
if (!mce_kobj) {
printk(KERN_ERR "Error creating a mce kset.\n");
err = -ENOMEM;
goto err_mce_kobj;
}
for (i = 0; i < ARRAY_SIZE(sysfs_attrs); i++) {
err = sysfs_create_file(mce_kobj, &sysfs_attrs[i]->attr);
if (err) {
printk(KERN_ERR "Error creating %s in sysfs.\n",
sysfs_attrs[i]->attr.name);
goto err_sysfs_create;
}
}
return 0;
err_sysfs_create:
while (--i >= 0)
sysfs_remove_file(mce_kobj, &sysfs_attrs[i]->attr);
kobject_del(mce_kobj);
err_mce_kobj:
edac_put_sysfs_class();
return err;
}
