Пример #1
0
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;
}
Пример #2
0
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);
}
Пример #3
0
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
}
Пример #4
0
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);
}
Пример #5
0
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);
}
Пример #6
0
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);
}
Пример #7
0
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);
}
Пример #8
0
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);
}
Пример #9
0
//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);
}
Пример #10
0
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]);
}
Пример #11
0
/*
 * 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);
}
Пример #13
0
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);
}
Пример #14
0
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);
}
Пример #16
0
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);

}
Пример #17
0
// 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;
}
Пример #18
0
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);
}
Пример #19
0
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);
}
Пример #21
0
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);
}
Пример #22
0
/*------------------------------------------------------------------------------
 */
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);
}
Пример #23
0
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);
}
Пример #24
0
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");
	}
}
Пример #25
0
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);	
}
Пример #29
0
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");
}
Пример #30
0
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);
    }