headphone_event 上报事件的分析

本文章讲解插入headphone的时候，向上层上报event函数的整个过程

headphone_event(wm8903->hp_state);

当有headphone 插入的时候，那么就将hp_state的状态设置为1

#ifdef CONFIG_I_LOVE_PBJ30

void headphone_event(int state)

{

switch_set_state(&wired_switch_dev, state);

}

EXPORT_SYMBOL_GPL(headphone_event);

#endif

headphone_event 函数会调用switch_set_state函数进行上报事件

staticstruct switch_dev wired_switch_dev = {

.name = "h2w",

};

void switch_set_state(struct switch_dev *sdev, int state)

{

char name_buf[120];

char state_buf[120];

char *prop_buf;

char *envp[3];

int env_offset = 0;

int length;

if (sdev->state != state) {

sdev->state = state;

prop_buf = (char *)get_zeroed_page(GFP_KERNEL);

if (prop_buf) {

length = name_show(sdev->dev, NULL, prop_buf);

if (length > 0) {

if (prop_buf[length - 1] == '\n')

prop_buf[length - 1] = 0;

snprintf(name_buf, sizeof(name_buf),

"SWITCH_NAME=%s", prop_buf);

envp[env_offset++] = name_buf;

}

length = state_show(sdev->dev, NULL, prop_buf);

if (length > 0) {

if (prop_buf[length - 1] == '\n')

prop_buf[length - 1] = 0;

snprintf(state_buf, sizeof(state_buf),

"SWITCH_STATE=%s", prop_buf);

envp[env_offset++] = state_buf;

}

envp[env_offset] = NULL;

kobject_uevent_env(&sdev->dev->kobj, KOBJ_CHANGE, envp);

free_page((unsignedlong)prop_buf);

} else {

printk(KERN_ERR "out of memory in switch_set_state\n");

kobject_uevent(&sdev->dev->kobj, KOBJ_CHANGE);

}

}

}

EXPORT_SYMBOL_GPL(switch_set_state);

讲解下上的switch_set_state函数

我们首先会判断sdev里面的状态和我们需要设置的状态是否一样，如果一样的话，那么就不需要去管它，如果不一样的话，那么就将state的值修改

上面主要会调用以下几个函数：

name_show:

state_show:

kobject_uevent_env:

在switch_set_state函数里面，会申请一个buffer，然后调用name_show函数

static ssize_t name_show(struct device *dev, struct device_attribute *attr,

char *buf)

{

struct switch_dev *sdev = (struct switch_dev *)

dev_get_drvdata(dev);

if (sdev->print_name) {

int ret = sdev->print_name(sdev, buf);

if (ret >= 0)

return ret;

}

return sprintf(buf, "%s\n", sdev->name);

}

name_show函数会判断sdev里面的print_name函数有没有被实现，如果没有实现的话，那么就将sdev->name的值输入到buf中去

我们的sdev里面实现的如下：

staticstruct switch_dev wired_switch_dev = {

.name = "h2w",

};

所以就直接将name 输入到buf中去

然后将输入到buf里面的值赋值到envp数组里面去：envp[env_offset++] = name_buf;

接下来的state_show函数的执行和上面的name_show函数是一样的，只是一个输出的是name，另外一个是state

也是将state的值赋值到envp 的数组里面去

接下来会调用kobject_uevent_env函数进行上报事件

kobject_uevent_env(&sdev->dev->kobj, KOBJ_CHANGE, envp);

kobject_uevent_env函数会首先判断 我这个kobject是属于哪个kset里面的，然后找出这个kset里面的uevent_ops

kobject_uevent_env函数的实现全部过程如下：

int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,

       char *envp_ext[])

{

struct kobj_uevent_env *env;

constchar *action_string = kobject_actions[action];

constchar *devpath = NULL;

constchar *subsystem;

struct kobject *top_kobj;

struct kset *kset;

conststruct kset_uevent_ops *uevent_ops;

u64 seq;

int i = 0;

int retval = 0;

#ifdef CONFIG_NET

struct uevent_sock *ue_sk;

#endif

pr_debug("kobject: '%s' (%p): %s\n",

 kobject_name(kobj), kobj, __func__);

/* search the kset we belong to */

top_kobj = kobj;

while (!top_kobj->kset && top_kobj->parent)//取出这个kobject属于哪一个kset

top_kobj = top_kobj->parent;

if (!top_kobj->kset) {

pr_debug("kobject: '%s' (%p): %s: attempted to send uevent "

 "without kset!\n", kobject_name(kobj), kobj,

 __func__);

return -EINVAL;

}

kset = top_kobj->kset;//找到这个kobject的kset成员

uevent_ops = kset->uevent_ops; //找到这个kset创建的时候，kset里面的uevent_ops成员

/* skip the event, if uevent_suppress is set*/

if (kobj->uevent_suppress) {//判断kobject里面有没有uvent_supress，如果有那么就代表这个

event是忽略的

pr_debug("kobject: '%s' (%p): %s: uevent_suppress "

 "caused the event to drop!\n",

 kobject_name(kobj), kobj, __func__);

return 0;

}

/* skip the event, if the filter returns zero. */

if (uevent_ops && uevent_ops->filter)

if (!uevent_ops->filter(kset, kobj)) {//kset里面的uevent_ops里面的filter成员决定是否将事件传递到用户空间去，如果返回0的话，那么就直接忽略，通过代码看的出来

pr_debug("kobject: '%s' (%p): %s: filter function "

 "caused the event to drop!\n",

 kobject_name(kobj), kobj, __func__);

return 0;

}

/* originating subsystem */

if (uevent_ops && uevent_ops->name)

subsystem = uevent_ops->name(kset, kobj);//调用uevent_ops里面的name成员将字符串传递给用户空间的热插拔程序

else

subsystem = kobject_name(&kset->kobj);

if (!subsystem) {

pr_debug("kobject: '%s' (%p): %s: unset subsystem caused the "

 "event to drop!\n", kobject_name(kobj), kobj,

 __func__);

return 0;

}

/* environment buffer */

env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);

if (!env)

return -ENOMEM;

/* complete object path */

devpath = kobject_get_path(kobj, GFP_KERNEL);

if (!devpath) {

retval = -ENOENT;

goto exit;

}

/* default keys */

retval = add_uevent_var(env, "ACTION=%s", action_string);

if (retval)

goto exit;

retval = add_uevent_var(env, "DEVPATH=%s", devpath);

if (retval)

goto exit;

retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);

if (retval)

goto exit;

/* keys passed in from the caller */

if (envp_ext) {

for (i = 0; envp_ext[i]; i++) {

retval = add_uevent_var(env, "%s", envp_ext[i]);//将我们设置的参数，添加到环境变量中去

if (retval)

goto exit;

}

}

/* let the kset specific function add its stuff */

if (uevent_ops && uevent_ops->uevent) {

retval = uevent_ops->uevent(kset, kobj, env);

if (retval) {

pr_debug("kobject: '%s' (%p): %s: uevent() returned "

 "%d\n", kobject_name(kobj), kobj,

 __func__, retval);

goto exit;

}

}

/*

 * Mark "add" and "remove" events in the object to ensure proper

 * events to userspace during automatic cleanup. If the object did

 * send an "add" event, "remove" will automatically generated by

 * the core, if not already done by the caller.

 */

if (action == KOBJ_ADD)

kobj->state_add_uevent_sent = 1;

elseif (action == KOBJ_REMOVE)

kobj->state_remove_uevent_sent = 1;

/* we will send an event, so request a new sequence number */

spin_lock(&sequence_lock);

seq = ++uevent_seqnum;

spin_unlock(&sequence_lock);

retval = add_uevent_var(env, "SEQNUM=%llu", (unsignedlonglong)seq);

if (retval)

goto exit;

#if defined(CONFIG_NET)

/* send netlink message */

mutex_lock(&uevent_sock_mutex);

list_for_each_entry(ue_sk, &uevent_sock_list, list) {

struct sock *uevent_sock = ue_sk->sk;

struct sk_buff *skb;

size_t len;

/* allocate message with the maximum possible size */

len = strlen(action_string) + strlen(devpath) + 2;

skb = alloc_skb(len + env->buflen, GFP_KERNEL);

if (skb) {

char *scratch;

/* add header */

scratch = skb_put(skb, len);

sprintf(scratch, "%s@%s", action_string, devpath);

/* copy keys to our continuous event payload buffer */

for (i = 0; i < env->envp_idx; i++) {

len = strlen(env->envp[i]) + 1;

scratch = skb_put(skb, len);

strcpy(scratch, env->envp[i]);

}

NETLINK_CB(skb).dst_group = 1;

retval = netlink_broadcast_filtered(uevent_sock, skb,

                               0, 1, GFP_KERNEL,

    kobj_bcast_filter,

    kobj);

/* ENOBUFS should be handled in userspace */

if (retval == -ENOBUFS)

retval = 0;

} else

retval = -ENOMEM;

}

mutex_unlock(&uevent_sock_mutex);

#endif

/* call uevent_helper, usually only enabled during early boot */

if (uevent_helper[0] && !kobj_usermode_filter(kobj)) {

char *argv [3];

argv [0] = uevent_helper;

argv [1] = (char *)subsystem;

argv [2] = NULL;

retval = add_uevent_var(env, "HOME=/");

if (retval)

goto exit;

retval = add_uevent_var(env,

"PATH=/sbin:/bin:/usr/sbin:/usr/bin");

if (retval)

goto exit;

retval = call_usermodehelper(argv[0], argv,

     env->envp, UMH_WAIT_EXEC);

}

exit:

kfree(devpath);

kfree(env);

return retval;

}

EXPORT_SYMBOL_GPL(kobject_uevent_env);

看下如何将用户空间需要的参数添加到环境变量中去的？？

传进去需要的参数

add_uevent_var(env, "%s", envp_ext[i]);

**

* add_uevent_var - add key value string to the environment buffer

* @env: environment buffer structure

* @format: printf format for the key=value pair

*

* Returns 0 if environment variable was added successfully or -ENOMEM

* if no space was available.

*/

int add_uevent_var(struct kobj_uevent_env *env, constchar *format, …)

{

va_list args;

int len;

if (env->envp_idx >= ARRAY_SIZE(env->envp)) {

WARN(1, KERN_ERR "add_uevent_var: too many keys\n");

return -ENOMEM;

}

va_start(args, format);

len = vsnprintf(&env->buf[env->buflen],

sizeof(env->buf) - env->buflen,

format, args);

va_end(args);

if (len >= (sizeof(env->buf) - env->buflen)) {

WARN(1, KERN_ERR "add_uevent_var: buffer size too small\n");

return -ENOMEM;

}

env->envp[env->envp_idx++] = &env->buf[env->buflen];

env->buflen += len + 1;

return 0;

}

EXPORT_SYMBOL_GPL(add_uevent_var);

上面的函数在将参数添加到环境变量中去，如果添加添加成功的话，那么就返回0