int batadv_throw_uevent(struct batadv_priv *bat_priv, enum batadv_uev_type type, enum batadv_uev_action action, const char *data) { int ret = -ENOMEM; struct batadv_hard_iface *primary_if = NULL; struct kobject *bat_kobj; char *uevent_env[4] = { NULL, NULL, NULL, NULL }; primary_if = batadv_primary_if_get_selected(bat_priv); if (!primary_if) goto out; bat_kobj = &primary_if->soft_iface->dev.kobj; uevent_env[0] = kmalloc(strlen(BATADV_UEV_TYPE_VAR) + strlen(batadv_uev_type_str[type]) + 1, GFP_ATOMIC); if (!uevent_env[0]) goto out; sprintf(uevent_env[0], "%s%s", BATADV_UEV_TYPE_VAR, batadv_uev_type_str[type]); uevent_env[1] = kmalloc(strlen(BATADV_UEV_ACTION_VAR) + strlen(batadv_uev_action_str[action]) + 1, GFP_ATOMIC); if (!uevent_env[1]) goto out; sprintf(uevent_env[1], "%s%s", BATADV_UEV_ACTION_VAR, batadv_uev_action_str[action]); /* If the event is DEL, ignore the data field */ if (action != BATADV_UEV_DEL) { uevent_env[2] = kmalloc(strlen(BATADV_UEV_DATA_VAR) + strlen(data) + 1, GFP_ATOMIC); if (!uevent_env[2]) goto out; sprintf(uevent_env[2], "%s%s", BATADV_UEV_DATA_VAR, data); } ret = kobject_uevent_env(bat_kobj, KOBJ_CHANGE, uevent_env); out: kfree(uevent_env[0]); kfree(uevent_env[1]); kfree(uevent_env[2]); if (primary_if) batadv_hardif_free_ref(primary_if); if (ret) batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Impossible to send uevent for (%s,%s,%s) event (err: %d)\n", batadv_uev_type_str[type], batadv_uev_action_str[action], (action == BATADV_UEV_DEL ? "NULL" : data), ret); return ret; }
static void gdlm_others_may_mount(void *lockspace) { char *message = "FIRSTMOUNT=Done"; char *envp[] = { message, NULL }; struct gdlm_ls *ls = lockspace; ls->first_done = 1; kobject_uevent_env(&ls->kobj, KOBJ_CHANGE, envp); }
void es705_vs_event(struct es705_priv *es705) { #if defined(SAMSUNG_ES705_FEATURE) #if 0// defined(SEAMLESS_VOICE_WAKEUP) /* UEvent*/ char keyword_buf[100]; unsigned int keyword_reg = 0; char *envp[2]; memset(keyword_buf, 0, sizeof(keyword_buf)); if (es705->voice_wakeup_enable == 1){ /* Voice wakeup */ keyword_reg = es705_priv.detected_vs_keyword; es705->keyword_type = keyword_reg; snprintf(keyword_buf, sizeof(keyword_buf), "VOICE_WAKEUP_WORD_ID=%x", keyword_reg); } else if (es705->voice_wakeup_enable == 2){ /* Voice wakeup LPSD */ snprintf(keyword_buf, sizeof(keyword_buf), "VOICE_WAKEUP_WORD_ID=LPSD"); } else { dev_info(es705->dev, "%s(): Invalid value(%d)\n", __func__, es705->voice_wakeup_enable); return; } envp[0] = keyword_buf; envp[1] = NULL; dev_info(es705->dev, "%s : raise the uevent, string = %s\n", __func__, keyword_buf); kobject_uevent_env(&(es705->keyword->kobj), KOBJ_CHANGE, envp); #else /* Key Event*/ unsigned int vs_event_type = 0; if (es705->voice_wakeup_enable == 1) /* Voice wakeup */ vs_event_type = KEY_VOICE_WAKEUP; else if (es705->voice_wakeup_enable == 2) /* Voice wakeup LPSD */ vs_event_type = KEY_VOICE_WAKEUP_LPSD; else { dev_info(es705->dev, "%s(): Invalid value(%d)\n", __func__, es705->voice_wakeup_enable); return; } dev_info(es705->dev, "%s(): Raise key event(%d)\n", __func__, vs_event_type); input_report_key(es705_priv.input, vs_event_type, 1); input_sync(es705_priv.input); msleep(10); input_report_key(es705_priv.input, vs_event_type, 0); input_sync(es705_priv.input); #endif #else struct slim_device *sbdev = es705->gen0_client; kobject_uevent(&sbdev->dev.kobj, KOBJ_CHANGE); #endif }
static void capture_work_1(struct work_struct *work) { char buf[64]; char *envp[2]; snprintf(buf, sizeof(buf), "CAPTURE1=BUFFER%d,TIME=%llu",bsp_disp_capture_screen_get_buffer_id(1), ktime_to_ns(capture_info.capture_timestamp[1])); envp[0] = buf; envp[1] = NULL; kobject_uevent_env(&capture_info.dev->kobj, KOBJ_CHANGE, envp); }
static void send_vsync_work_1(struct work_struct *work) { char buf[64]; char *envp[2]; snprintf(buf, sizeof(buf), "VSYNC1=%llu",ktime_to_ns(g_fbi.vsync_timestamp[1])); envp[0] = buf; envp[1] = NULL; kobject_uevent_env(&g_fbi.dev->kobj, KOBJ_CHANGE, envp); }
static void ssm_notify(struct ssm_data *sd, enum ssm_state state) { char event[8]; char *envp[] = {event, NULL}; snprintf(event, sizeof(event), "EVENT=%d", state); dev_dbg(sd->dev, "%s: Sending uevent EVENT=%d\n", __func__, state); kobject_uevent_env(&sd->dev->kobj, KOBJ_CHANGE, envp); }
static void tmp102_uevent_send(struct tmp102_temp_sensor *tmp102) { char buf[32]; char *envp[3]; envp[0] = "NAME=PCB_TEMPERATURE"; snprintf(buf, 32, "TEMPERATURE=%d", tmp102->temp); envp[1] = buf; envp[2] =NULL; kobject_uevent_env(&(tmp102->iclient->dev.kobj),KOBJ_CHANGE,envp); }
static void check_state_work(struct work_struct *work) { char buf[64]; char *envp[2]; snprintf(buf, sizeof(buf), "NAME=ESD"); envp[0] = buf; envp[1] = NULL; kobject_uevent_env(&pdev_backup->dev.kobj, KOBJ_CHANGE, envp); printk("Taylor: kobject name=%s\n",(&pdev_backup->dev.kobj)->name); }
//schedule a work to send uevent static void uevent_work_func(struct work_struct *data) { char *reset[2] = { "MODEM_STATE=0", NULL }; char *power_on[2] = { "MODEM_STATE=1", NULL }; char **uevent_envp = NULL; unsigned long flags; struct modem_boot_device *mdevice = container_of(data, struct modem_boot_device, work); spin_lock_irqsave(&mdevice->lock, flags); uevent_envp = (mdevice->modem_state == MODEM_STATE_POWERON) ? power_on : reset; spin_unlock_irqrestore(&mdevice->lock, flags); kobject_uevent_env(&mdevice->device->kobj, KOBJ_CHANGE, uevent_envp); }
static void hdmi_sys_send_uevent(int uevent) { char *envp[3]; envp[0] = "INTERFACE=HDMI"; envp[1] = kmalloc(32, GFP_KERNEL); if(envp[1] == NULL) return; sprintf(envp[1], "SCREEN=%d", hdmi->ddev->property); envp[2] = NULL; kobject_uevent_env(&hdmi->ddev->dev->kobj, uevent, envp); kfree(envp[1]); }
/* * NL5350 device driver */ static void nl5350_irq_worker(struct work_struct *work) { struct nl5350_struct *nl5350 = container_of(work, struct nl5350_struct, work); struct platform_device *pdev = nl5350->pdev; static const char *envp[] = { "INTERRUPT", NULL, }; dev_dbg(&pdev->dev, "nl5350_irq_worker: sending uevent\n"); kobject_uevent_env(&pdev->dev.kobj, KOBJ_CHANGE, (char**)envp); }
static void send_vsync_work(struct work_struct *work) { struct vsycn_ctrl *vctrl = container_of(work, typeof(*vctrl), vsync_work); char buf[64]; char *envp[2]; snprintf(buf, sizeof(buf), "VSYNC=%llu", ktime_to_ns(vctrl->vsync_time)); envp[0] = buf; envp[1] = NULL; kobject_uevent_env(&vctrl->dev->kobj, KOBJ_CHANGE, envp); }
static void gdlm_recovery_done(void *lockspace, unsigned int jid, unsigned int message) { char env_jid[20]; char env_status[20]; char *envp[] = { env_jid, env_status, NULL }; struct gdlm_ls *ls = lockspace; ls->recover_jid_done = jid; ls->recover_jid_status = message; sprintf(env_jid, "JID=%d", jid); sprintf(env_status, "RECOVERY=%s", message == LM_RD_SUCCESS ? "Done" : "Failed"); kobject_uevent_env(&ls->kobj, KOBJ_CHANGE, envp); }
static int mtlte_sys_trigger_auto_calibration(void *data) { char *envp[3]; char *p; int u4Func = 1; int err; struct mmc_host *host; printk("[%s] Enter %s\n", __func__, __func__); if(lte_autok_running == 3) { printk("[%s] LTE auto-K is running\n", __func__); return -1; } lte_autok_running++; if(lte_dev.sdio_func == NULL) { printk("[%s] LTE have not probed\n", __func__); return -1; } host = lte_dev.sdio_func->card->host; envp[0] = "FROM=lte_drv"; envp[1] = "SDIOFUNC=0xXXXXXXXX"; envp[2] = NULL; //p = strstr(envp[1], "0xXXXXXXXX"); p = envp[1]+9; // point to the beginning of 0xXXXXXXXX sprintf(p, "0x%x", (unsigned int)(host->card->sdio_func[u4Func - 1])); // printk("[%s] envp[0] = %s, envp[1] = %s, host->class_dev.kobj.name = %s\n", __func__, envp[0], envp[1], host->class_dev.kobj.name); // printk("[%s] host = 0x%x, host->class_dev.kobj.name = %s\n", __func__, host, host->class_dev.kobj.name); KAL_SLEEP_SEC(1); err = kobject_uevent_env(&host->class_dev.kobj, KOBJ_ONLINE, envp); if(err < 0) { printk("kobject_uevent_env error = %d\n", err); return -1; } return 0; }
static void notify_change_of_temperature(struct sec_therm_info *info) { char temp_buf[20]; char siop_buf[20]; #if defined(CONFIG_MACH_HLTEDCM) || defined(CONFIG_MACH_HLTEKDI) || \ defined(CONFIG_MACH_JS01LTEDCM) || defined(CONFIG_MACH_KLTE_JPN) || \ defined(CONFIG_MACH_KACTIVELTE_DCM) char *envp[4]; #else char *envp[3]; #endif int env_offset = 0; int siop_level = -1; #if defined(CONFIG_MACH_HLTEDCM) || defined(CONFIG_MACH_HLTEKDI) || \ defined(CONFIG_MACH_JS01LTEDCM) || defined(CONFIG_MACH_KLTE_JPN) || \ defined(CONFIG_MACH_KACTIVELTE_DCM) char temp_buf_flash[20]; snprintf(temp_buf, sizeof(temp_buf), "SUBTEMPERATURE=%d", info->curr_temperature); envp[env_offset++] = temp_buf; snprintf(temp_buf_flash, sizeof(temp_buf_flash), "FLASH_TEMP=%d", info->curr_temperature_flash_led); envp[env_offset++] = temp_buf_flash; #else snprintf(temp_buf, sizeof(temp_buf), "TEMPERATURE=%d", info->curr_temperature); envp[env_offset++] = temp_buf; #endif if (info->pdata->get_siop_level) siop_level = info->pdata->get_siop_level(info->curr_temperature); if (siop_level >= 0) { snprintf(siop_buf, sizeof(siop_buf), "SIOP_LEVEL=%d", siop_level); envp[env_offset++] = siop_buf; dev_info(info->dev, "%s: uevent: %s\n", __func__, siop_buf); } else { envp[env_offset++] = NULL; } envp[env_offset] = NULL; dev_info(info->dev, "%s: siop_level=%d\n", __func__, siop_level); dev_info(info->dev, "%s: uevent: %s\n", __func__, temp_buf); kobject_uevent_env(&info->dev->kobj, KOBJ_CHANGE, envp); }
static void s3c_vsync_kobject_uevent(void) { char env_buf[120]; char *envp[2]; int env_offset = 0; long long cur_vsync; cur_vsync = s3cfb_get_system_time(); sprintf(env_buf, "VSYNC=%lld",cur_vsync); envp[env_offset++] = env_buf; envp[env_offset] = NULL; kobject_uevent_env(&( fbfimd->fbdev[0]->dev->kobj), KOBJ_CHANGE, envp); }
// USBIF , to send IF uevent int usbif_u3d_test_send_event(char* event) { char udev_event[128]; char *envp[] = {udev_event, NULL }; int ret ; snprintf(udev_event, 128, "USBIF_EVENT=%s",event); printk("usbif_u3d_test_send_event - sending %s event - %s in %s\n", udev_event, kobject_get_path(&mu3d_test_uevent_device.this_device->kobj, GFP_KERNEL)); ret = kobject_uevent_env(&mu3d_test_uevent_device.this_device->kobj, KOBJ_CHANGE, envp); if (ret < 0) printk("mu3d_test_uevent_device sending failed with ret = %d, \n", ret); return ret; }
void crash_event(int type) { char *envs[2] = { NULL, NULL }; if (!global_mc) return; #ifdef CONFIG_SEC_DEBUG envs[0] = (type == SVNET_ERROR_CRASH) ? "MAILBOX=cp_exit" : "MAILBOX=cp_reset"; #else envs[0] = "MAILBOX=cp_reset"; #endif kobject_uevent_env(&global_mc->dev->kobj, KOBJ_OFFLINE, envs); }
static int mtk_cl_shutdown_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state) { #if defined(MTK_COOLER_SHUTDOWN_SIGNAL) //volatile unsigned long original_state; #endif //mtk_cooler_shutdown_dprintk("mtk_cl_shutdown_set_cur_state() %s %d\n", cdev->type, state); #if defined(MTK_COOLER_SHUTDOWN_SIGNAL) //original_state = *((unsigned long*) cdev->devdata); #endif *((unsigned long*) cdev->devdata) = state; if (0 == state) { if (sd_cnt > 0) sd_cnt--; else ; } else if (1 == state) { sd_cnt++; } if (sd_debouncet == sd_cnt) { #if defined(MTK_COOLER_SHUTDOWN_UEVENT) { // send uevent to notify current call must be dropped char event[] = "SHUTDOWN=1"; char *envp[] = { event, NULL }; kobject_uevent_env(&(cdev->device.kobj), KOBJ_CHANGE, envp); } #endif #if defined(MTK_COOLER_SHUTDOWN_SIGNAL) if (0 == sd_happened) // make this an edge trigger instead of level trigger { // send signal to target process _mtk_cl_sd_send_signal(); sd_happened = 1; } #endif } return 0; }
static void notify_change_of_temperature(struct sec_therm_info *info) { char temp_buf[20]; char *envp[2]; int env_offset = 0; snprintf(temp_buf, sizeof(temp_buf), "TEMPERATURE=%d", info->curr_temperature); envp[env_offset++] = temp_buf; envp[env_offset] = NULL; dev_info(info->dev, "%s: uevent: %s\n", __func__, temp_buf); kobject_uevent_env(&info->dev->kobj, KOBJ_CHANGE, envp); }
void stheno_remove_card(void) { struct kobject* kobj; static char env_major[32]; char* env[16]; int i; seg_info.dirty = 0; if (!stheno_gd) return; kobj = get_disk(stheno_gd); if (!kobj) return; sprintf(env_major, "MAJOR=%d", stheno_major); i = 0; env[i++] = env_major; env[i++] = "MINOR=0"; env[i++] = "DEVNAME=stheno"; env[i++] = "DEVTYPE="; env[i++] = "PARTN=1"; env[i++] = NULL; kobject_uevent_env(kobj, KOBJ_REMOVE, env); #if 0 i = 0; env[i++] = env_major; env[i++] = "MINOR=0"; env[i++] = "DEVNAME=stheno"; env[i++] = "DEVTYPE=disk"; env[i++] = "NPARTS=1"; env[i++] = NULL; kobject_uevent_env(kobj, KOBJ_REMOVE, env); #endif put_disk(stheno_gd); }
/*------------------------------------------------------------------------------ */ static void oz_pd_uevent_workitem(struct work_struct *work) { struct oz_pd *pd; char mac_buf[20]; char *envp[2]; pd = container_of(work, struct oz_pd, uevent_workitem); oz_trace_msg(D, "uevent ID_MAC:%pm\n", pd->mac_addr); snprintf(mac_buf, sizeof(mac_buf), "ID_MAC=%pm", pd->mac_addr); envp[0] = mac_buf; envp[1] = NULL; kobject_uevent_env(&g_oz_wpan_dev->kobj, KOBJ_CHANGE, envp); oz_pd_put(pd); }
static int notify_change_of_tmu_state(struct s5p_tmu_info *info) { char temp_buf[20]; char *envp[2]; int env_offset = 0; snprintf(temp_buf, sizeof(temp_buf), "TMUSTATE=%d", info->tmu_state); envp[env_offset++] = temp_buf; envp[env_offset] = NULL; pr_info("%s: uevent: %d, name = %s\n", __func__, info->tmu_state, temp_buf); return kobject_uevent_env(&info->dev->kobj, KOBJ_CHANGE, envp); }
static void psensor_work_func(struct work_struct *work) { int ps_out_status; char *event_string_0[] = { "ps_out=0", NULL }; char *event_string_1[] = { "ps_out=1", NULL }; ps_out_status = gpio_get_value(PSENSOR_INT_GPIO); if(dynamic_log_ebable) printk(KERN_ERR "Jackie: PS_INT!! ps_out_status=%d\n", ps_out_status); if(ps_out_status == 0) { if ( (system_rev==EVT2_Band125) || (system_rev==EVT2_Band18) ) { kobject_uevent_env(&misc_psensor_device.this_device->kobj, KOBJ_CHANGE, event_string_1); DBGPRINTK(KERN_ERR "Jackie: PS_OUT low...closed, but force return leaved at EVT2 !!\n"); } else { kobject_uevent_env(&misc_psensor_device.this_device->kobj, KOBJ_CHANGE, event_string_0); atomic_set(&psensor_approached, 1); DBGPRINTK(KERN_ERR "Jackie: PS_OUT low...closed !!\n"); } } else { kobject_uevent_env(&misc_psensor_device.this_device->kobj, KOBJ_CHANGE, event_string_1); atomic_set(&psensor_approached, 0); DBGPRINTK(KERN_ERR "Jackie: PS_OUT high...leaved !!\n"); } }
static int set_wow(struct tegra_wakeup_monitor *twm, bool enable) { char *envp[2]; if (enable) envp[0] = TEGRA_WOW_WAKEUP_ENABLE; else envp[0] = TEGRA_WOW_WAKEUP_DISABLE; envp[1] = NULL; /* Sent out a uevent to broadcast wow enable change*/ kobject_uevent_env(&twm->pdev->dev.kobj, KOBJ_CHANGE, envp); dev_info(&twm->pdev->dev, "wakeup moniter: set_wow = %d\n", (int)enable); return 0; }
int lge_qsdl_trigger_modem_uevent(void) { char *noti_modem_info[2] = {"QSDL=Q005", NULL}; char **uevent_envp = NULL; if (lge_qsdl_dev) { uevent_envp = noti_modem_info; kobject_uevent_env(&lge_qsdl_dev->kobj, KOBJ_CHANGE, uevent_envp); pr_debug("%s: Notify modem qsdl infomation\n", __func__); } else { pr_debug("%s: Fail to Notify modem qsdl infomation\n", __func__); } return 0; }
/*************************************************************************** *Function: wlan_send_nl_event *Description: send the port number to the userspace use uevent. *Input: struct net_device *net_dev: dhd net device. u16 port: port number. *Output: null *Return: null ***************************************************************************/ static void wlan_send_nl_event(struct net_device *net_dev, u16 port) { struct device* dev = NULL; char *uevent[2]; char msg[MAX_MSG_LENGTH]; dev = &(net_dev->dev); memset(msg, 0, sizeof(msg)); snprintf(msg, sizeof(msg), "WIFI_WAKE_PORT=%d",port); HW_PRINT_HI("%s: send msg: %s\n", __FUNCTION__, msg); uevent[0] = msg; uevent[1] = NULL; kobject_uevent_env(&(dev->kobj), KOBJ_CHANGE, (char**)&uevent); return; }
void crash_event(int type) { char *envs[2] = { NULL, NULL }; if (!global_mc) return; #if 0 envs[0] = (type == SVNET_ERROR_CRASH) ? "MAILBOX=cp_exit" : "MAILBOX=cp_reset"; #else envs[0] = "MAILBOX=lte_reset"; #endif printk(KERN_ERR "%s\n", __func__); kobject_uevent_env(&global_mc->dev->kobj, KOBJ_CHANGE, envs); }
static void cci_pm_early_suspend(struct early_suspend *h) { char *buf; char *envp[3]; buf = kmalloc(32, GFP_ATOMIC); if (!buf){ printk(KERN_ERR "%s kmalloc failed\n", __func__); } envp[0] = "NAME=cci_pm"; snprintf(buf, 32, "EVENT=0"); envp[1] = buf; envp[2] = NULL; kobject_uevent_env(&cci_pm_dev->dev.kobj, KOBJ_CHANGE, envp); kfree(buf); printk("[CCI/SOMC]-send request next suspend prepare_notification\n"); }
void send_cpu_usage_stats_kobject_uevent(char *buf_pid) { int ok_to_send = 0; char *envp[3] = {SUBSYSTEM_CPU_USAGE_STATS, 0, 0}; if (strlen(buf_pid)) { envp[1] = buf_pid; ok_to_send = 1; } if ((pdev_local != NULL) && ok_to_send) { kobject_uevent_env(&pdev_local->dev.kobj, KOBJ_CHANGE, envp); }