目录
1 描述
2 结构体
2.1 input_class
2.2 input_dev
2.4 input_event
2.4 input_dev_type
3 input接口
3.1 input_allocate_device
3.2 input_free_device
3.3 input_register_device
3.4 input_unregister_device
3.5 input_event
3.6 input_sync
3.7 input_set_capability
4 input.c分析
4.1 注册字符设备
4.2 函数分析
4.2.1 class_register
4.2.2 dev_name
4.2.3 register_chrdev_region
4.2.3 MKDEV
5 示例
5.1 示例 1
5.1.1 代码
5.1.2 操作
5.2 mcu_cec驱动分析
5.2.1 注册输入事件
5.2.2 函数分析
5.2.2.1 devm_input_allocate_device
5.2.3 上报事件
1 描述
input 子系统分为 input 驱动层、input 核心层、input 事件处理层，最终给用户空间提供可访问的设备节点，input 子系统框架如图
驱动层：输入设备的具体驱动程序，比如按键驱动程序，向内核层报告输入内容。
核心层：承上启下，为驱动层提供输入设备 注册和操作接口。通知事件层对输入事件进行 处理。
事件层：主要和用户空间进行交互。
input 核心层会向 Linux 内核注册一个字符设备，在 drivers/input/input.c文件中描述
如何找到input 设备节点文件对应的具体设备？
方法（1）：使用sudo cat 命令打开/dev/input/下的设备节点文件，然后分别操作各个输入设备，如果有输出有乱码，说明此时打开的设备文件就对应于当前的输入设备。
方法（2）：使用sudo hexdump 命令打开/dev/input/下设备文件，然后分别操作各个输入设备，如果有输出16进制数，说明此时打开的设备文件就对应于当前的输入设备。
方法（3）：查看/proc/bus/input/devices文件，里面记载了各个已经安装输入设备的信息。通过文件内容name和handler来查看设备文件与设备的对应关系。
127|rk3399_Android11:/ # cat /proc/bus/input/devices
I: Bus=0019 Vendor=524b Product=0006 Version=0100
N: Name="ff420030.pwm"
P: Phys=gpio-keys/remotectl
S: Sysfs=/devices/platform/ff420030.pwm/input/input0
U: Uniq=
H: Handlers=event0 cpufreq dmcfreq
B: PROP=0
B: EV=3
B: KEY=70010 20000000000000 0 100010002000000 78000004000a800 1e16c000000000 10004ffc
I: Bus=0019 Vendor=0001 Product=0001 Version=0100
N: Name="adc_keys"
P: Phys=adc-keys/input0
S: Sysfs=/devices/platform/adc_keys/input/input1
U: Uniq=
H: Handlers=event1 cpufreq dmcfreq
B: PROP=0
B: EV=3
B: KEY=c000000000000 0
I: Bus=0019 Vendor=0001 Product=0001 Version=0100
N: Name="gpio-keys"
P: Phys=gpio-keys/input0
S: Sysfs=/devices/platform/gpio-keys/input/input2
U: Uniq=
H: Handlers=event2 cpufreq dmcfreq
B: PROP=0
B: EV=100003
B: KEY=10000000000000 0
I: Bus=0000 Vendor=0001 Product=0001 Version=0100
N: Name="rk-headset"
P: Phys=
S: Sysfs=/devices/platform/rk-headset/input/input3
U: Uniq=
H: Handlers=event3
B: PROP=0
B: EV=3
B: KEY=400000000 0 0 0
rk3399_Android11:/ #2 结构体
2.1 input_class
1782 struct class input_class = {
1783 .name = "input",
1784 .devnode = input_devnode,
1785 };2.2 input_dev
input_dev 结构体是用于描述和管理输入设备的复杂数据结构，涵盖了设备的基本信息、支持的事件、状态管理、操作函数等多个方面，是 Linux 输入子系统的重要组成部分。
130 struct input_dev {
131 const char *name;
132 const char *phys;
133 const char *uniq;
134 struct input_id id;
135
136 unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];
137
138 unsigned long evbit[BITS_TO_LONGS(EV_CNT)];
139 unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];
140 unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
141 unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];
142 unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
143 unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
144 unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
145 unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
146 unsigned long swbit[BITS_TO_LONGS(SW_CNT)];
147
148 unsigned int hint_events_per_packet;
149
150 unsigned int keycodemax;
151 unsigned int keycodesize;
152 void *keycode;
153
154 int (*setkeycode)(struct input_dev *dev,
155 const struct input_keymap_entry *ke,
156 unsigned int *old_keycode);
157 int (*getkeycode)(struct input_dev *dev,
158 struct input_keymap_entry *ke);
159
160 struct ff_device *ff;
161
162 unsigned int repeat_key;
163 struct timer_list timer;
164
165 int rep[REP_CNT];
166
167 struct input_mt *mt;
168
169 struct input_absinfo *absinfo;
170
171 unsigned long key[BITS_TO_LONGS(KEY_CNT)];
172 unsigned long led[BITS_TO_LONGS(LED_CNT)];
173 unsigned long snd[BITS_TO_LONGS(SND_CNT)];
174 unsigned long sw[BITS_TO_LONGS(SW_CNT)];
175
176 int (*open)(struct input_dev *dev);
177 void (*close)(struct input_dev *dev);
178 int (*flush)(struct input_dev *dev, struct file *file);
179 int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
180
181 struct input_handle __rcu *grab;
182
183 spinlock_t event_lock;
184 struct mutex mutex;
185
186 unsigned int users;
187 bool going_away;
188
189 struct device dev;
190
191 struct list_head h_list;
192 struct list_head node;
193
194 unsigned int num_vals;
195 unsigned int max_vals;
196 struct input_value *vals;
197
198 bool devres_managed;
199
200 ktime_t timestamp[INPUT_CLK_MAX];
201 };基本信息
const char *name;
const char *phys;
const char *uniq;
name: 输入设备的名称。
phys: 物理路径，通常用于描述设备的实际连接地址。
uniq: 设备的唯一标识符，用于区分不同设备。
设备 ID
struct input_id id;
id: 包含设备类型、制造商和产品 ID 的结构体，用于唯一标识输入设备。
属性位
unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];
这些位字段用于表示设备的特性（如支持哪些输入属性）。
evbit: 表示设备支持的事件类型（如按键、鼠标移动等）。
keybit: 表示支持的按键。
relbit: 表示支持的相对坐标变化事件（如鼠标移动）。
absbit: 表示支持的绝对坐标事件。
mscbit: 表示支持的特殊事件类型。
ledbit: 表示支持的 LED 控制。
sndbit: 表示支持的声音控制。
ffbit: 表示支持的力反馈事件。
swbit: 表示支持的开关状态。
键盘设置
unsigned int keycodemax;
unsigned int keycodesize;
void *keycode;
keycodemax: 最大键码数量。
keycodesize: 每个键码的大小。
keycode: 指向键码数组的指针。
键码处理函数
int (*setkeycode)(struct input_dev *dev, const struct input_keymap_entry *ke, unsigned int *old_keycode);
int (*getkeycode)(struct input_dev *dev, struct input_keymap_entry *ke);
setkeycode: 设置键码的回调函数。
getkeycode: 获取键码的回调函数。
其他功能
unsigned int repeat_key;
struct timer_list timer;
repeat_key: 用于设置键重复的时间间隔。
timer: 定时器，用于处理键重复事件。
多点触控和绝对信息
struct input_mt *mt;
struct input_absinfo *absinfo;
mt: 多点触控相关信息。
absinfo: 绝对坐标信息。
状态管理
unsigned long key[BITS_TO_LONGS(KEY_CNT)];
unsigned long led[BITS_TO_LONGS(LED_CNT)];
unsigned long snd[BITS_TO_LONGS(SND_CNT)];
unsigned long sw[BITS_TO_LONGS(SW_CNT)];
用于存储设备当前状态的信息，包括按键状态、LED 状态、声音状态和开关状态。
设备操作函数
int (*open)(struct input_dev *dev);
void (*close)(struct input_dev *dev);
int (*flush)(struct input_dev *dev, struct file *file);
int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
open: 打开设备的回调函数。
close: 关闭设备的回调函数。
flush: 刷新设备状态的回调函数。
event: 处理输入事件的回调函数。
锁和同步
spinlock_t event_lock;
struct mutex mutex;
event_lock: 自旋锁，用于保护事件队列。
mutex: 互斥锁，用于设备操作的同步。
引用计数和状态
unsigned int users;
bool going_away;
users: 当前打开设备的用户数量。
going_away: 表示设备是否正在被移除。
设备结构
struct device dev;
dev: 表示内核设备结构，包含设备的基本信息。
列表和管理
struct list_head h_list;
struct list_head node;
h_list: 用于哈希表中的链表节点。
node: 用于设备列表中的链表节点。
值管理
unsigned int num_vals;
unsigned int max_vals;
struct input_value *vals;
num_vals: 当前值的数量。
max_vals: 最大值数量。
vals: 指向输入值数组的指针。
设备资源管理
bool devres_managed;
devres_managed: 表示设备资源是否由设备管理系统管理。
时间戳
ktime_t timestamp[INPUT_CLK_MAX];
存储输入事件的时间戳。
2.4 input_event
Linux 内核使用 input_event 这个结构体来表示所有的输入事件
28 struct input_event {
29 #if (__BITS_PER_LONG != 32 || !defined(__USE_TIME_BITS64)) && !defined(__KERNEL__)
30 struct timeval time;
31 #define input_event_sec time.tv_sec
32 #define input_event_usec time.tv_usec
33 #else
34 __kernel_ulong_t __sec;
35 #if defined(__sparc__) && defined(__arch64__)
36 unsigned int __usec;
37 unsigned int __pad;
38 #else
39 __kernel_ulong_t __usec;
40 #endif
41 #define input_event_sec __sec
42 #define input_event_usec __usec
43 #endif
44 __u16 type;
45 __u16 code;
46 __s32 value;
47 };type：事件类型，比如 EV_KEY，表示此次事件为按键事件，此成员变量为 16 位。
code：事件码，比如在 EV_KEY 事件中 code 就表示具体的按键码，如：KEY_0、KEY_1等等这些按键。此成员变量为 16 位。
value：值，比如 EV_KEY 事件中 value 就是按键值，表示按键有没有被按下，如果为 1 的话说明按键按下，如果为 0 的话说明按键没有被按下或者按键松开了。
2.4 input_dev_type
1768 static const struct device_type input_dev_type = {
1769 .groups = input_dev_attr_groups,
1770 .release = input_dev_release,
1771 .uevent = input_dev_uevent,
1772 #ifdef CONFIG_PM_SLEEP
1773 .pm = &input_dev_pm_ops,
1774 #endif
1775 };1519 static const struct attribute_group *input_dev_attr_groups[] = {
1520 &input_dev_attr_group,
1521 &input_dev_id_attr_group,
1522 &input_dev_caps_attr_group,
1523 NULL
1524 };1526 static void input_dev_release(struct device *device)
1527 {
1528 struct input_dev *dev = to_input_dev(device);
1529
1530 input_ff_destroy(dev);
1531 input_mt_destroy_slots(dev);
1532 kfree(dev->absinfo);
1533 kfree(dev->vals);
1534 kfree(dev);
1535
1536 module_put(THIS_MODULE);
1537 }1759 static const struct dev_pm_ops input_dev_pm_ops = {
1760 .suspend = input_dev_suspend,
1761 .resume = input_dev_resume,
1762 .freeze = input_dev_freeze,
1763 .poweroff = input_dev_poweroff,
1764 .restore = input_dev_resume,
1765 };3 input接口
3.1 input_allocate_device
| 函数原型 | struct input_dev *input_allocate_device(void) | |
| 返回值 | struct input_dev * | 成功：input_dev结构体指针 失败：NULL |
| 功能 | 申请一个 input_dev | |
1797 struct input_dev *input_allocate_device(void)
1798 {
1799 static atomic_t input_no = ATOMIC_INIT(-1);
1800 struct input_dev *dev;
1801
1802 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1803 if (dev) {
1804 dev->dev.type = &input_dev_type;
1805 dev->dev.class = &input_class;
1806 device_initialize(&dev->dev);
1807 mutex_init(&dev->mutex);
1808 spin_lock_init(&dev->event_lock);
1809 timer_setup(&dev->timer, NULL, 0);
1810 INIT_LIST_HEAD(&dev->h_list);
1811 INIT_LIST_HEAD(&dev->node);
1812
1813 dev_set_name(&dev->dev, "input%lu",
1814 (unsigned long)atomic_inc_return(&input_no));
1815
1816 __module_get(THIS_MODULE);
1817 }
1818
1819 return dev;
1820 } 1768 static const struct device_type input_dev_type = {
1769 .groups = input_dev_attr_groups,
1770 .release = input_dev_release,
1771 .uevent = input_dev_uevent,
1772 #ifdef CONFIG_PM_SLEEP
1773 .pm = &input_dev_pm_ops,
1774 #endif
1775 };3.2 input_free_device
| 函数原型 | void input_free_device(struct input_dev *dev) | |
| 参数 | struct input_dev * | input_dev结构体指针 |
| 功能 | 释放一个 input_dev | |
1902 void input_free_device(struct input_dev *dev)
1903 {
1904 if (dev) {
1905 if (dev->devres_managed)
1906 WARN_ON(devres_destroy(dev->dev.parent,
1907 devm_input_device_release,
1908 devm_input_device_match,
1909 dev));
1910 input_put_device(dev);
1911 }
1912 }3.3 input_register_device
| 函数原型 | int input_register_device(struct input_dev *dev) | |
| 参数 | struct input_dev *dev | input_dev结构体指针 |
| 返回值 | int | 成功：0 失败：错误码 |
| 功能 | 向 Linux 内核注册 input_dev | |
2140 int input_register_device(struct input_dev *dev)
2141 {
2142 struct input_devres *devres = NULL;
2143 struct input_handler *handler;
2144 unsigned int packet_size;
2145 const char *path;
2146 int error;
2147
2148 if (test_bit(EV_ABS, dev->evbit) && !dev->absinfo) {
2149 dev_err(&dev->dev,
2150 "Absolute device without dev->absinfo, refusing to register\n");
2151 return -EINVAL;
2152 }
2153
2154 if (dev->devres_managed) {
2155 devres = devres_alloc(devm_input_device_unregister,
2156 sizeof(*devres), GFP_KERNEL);
2157 if (!devres)
2158 return -ENOMEM;
2159
2160 devres->input = dev;
2161 }
2162
2163 /* Every input device generates EV_SYN/SYN_REPORT events. */
2164 __set_bit(EV_SYN, dev->evbit);
2165
2166 /* KEY_RESERVED is not supposed to be transmitted to userspace. */
2167 __clear_bit(KEY_RESERVED, dev->keybit);
2168
2169 /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
2170 input_cleanse_bitmasks(dev);
2171
2172 packet_size = input_estimate_events_per_packet(dev);
2173 if (dev->hint_events_per_packet < packet_size)
2174 dev->hint_events_per_packet = packet_size;
2175
2176 dev->max_vals = dev->hint_events_per_packet + 2;
2177 dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
2178 if (!dev->vals) {
2179 error = -ENOMEM;
2180 goto err_devres_free;
2181 }
2182
2183 /*
2184 * If delay and period are pre-set by the driver, then autorepeating
2185 * is handled by the driver itself and we don't do it in input.c.
2186 */
2187 if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD])
2188 input_enable_softrepeat(dev, 250, 33);
2189
2190 if (!dev->getkeycode)
2191 dev->getkeycode = input_default_getkeycode;
2192
2193 if (!dev->setkeycode)
2194 dev->setkeycode = input_default_setkeycode;
2195
2196 error = device_add(&dev->dev);
2197 if (error)
2198 goto err_free_vals;
2199
2200 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
2201 pr_info("%s as %s\n",
2202 dev->name ? dev->name : "Unspecified device",
2203 path ? path : "N/A");
2204 kfree(path);
2205
2206 error = mutex_lock_interruptible(&input_mutex);
2207 if (error)
2208 goto err_device_del;
2209
2210 list_add_tail(&dev->node, &input_dev_list);
2211
2212 list_for_each_entry(handler, &input_handler_list, node)
2213 input_attach_handler(dev, handler);
2214
2215 input_wakeup_procfs_readers();
2216
2217 mutex_unlock(&input_mutex);
2218
2219 if (dev->devres_managed) {
2220 dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
2221 __func__, dev_name(&dev->dev));
2222 devres_add(dev->dev.parent, devres);
2223 }
2224 return 0;
2225
2226 err_device_del:
2227 device_del(&dev->dev);
2228 err_free_vals:
2229 kfree(dev->vals);
2230 dev->vals = NULL;
2231 err_devres_free:
2232 devres_free(devres);
2233 return error;
2234 }3.4 input_unregister_device
| 函数原型 | void input_unregister_device(struct input_dev *dev) | |
| 参数 | struct input_dev *dev | input_dev结构体指针 |
| 返回值 | ||
| 功能 | 向 Linux 内核注销input_dev | |
2244 void input_unregister_device(struct input_dev *dev)
2245 {
2246 if (dev->devres_managed) {
2247 WARN_ON(devres_destroy(dev->dev.parent,
2248 devm_input_device_unregister,
2249 devm_input_device_match,
2250 dev));
2251 __input_unregister_device(dev);
2252 /*
2253 * We do not do input_put_device() here because it will be done
2254 * when 2nd devres fires up.
2255 */
2256 } else {
2257 __input_unregister_device(dev);
2258 input_put_device(dev);
2259 }
2260 }3.5 input_event
| 函数原型 | void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) | |
| 参数 | struct input_dev *dev | 需要上报的 input_dev |
| unsigned int type | 上报的事件类型，比如 EV_KEY | |
| unsigned int code | 事件码，也就是我们注册的按键值，比如 KEY_0、KEY_1 | |
| int value | 事件值，比如 1 表示按键按下，0 表示按键松开 | |
| 返回值 | ||
| 功能 | 上报指定的事件以及对应的值 | |
436 void input_event(struct input_dev *dev,
437 unsigned int type, unsigned int code, int value)
438 {
439 unsigned long flags;
440
441 if (is_event_supported(type, dev->evbit, EV_MAX)) {
442
443 spin_lock_irqsave(&dev->event_lock, flags);
444 input_handle_event(dev, type, code, value);
445 spin_unlock_irqrestore(&dev->event_lock, flags);
446 }
447 }3.6 input_sync
| 函数原型 | static inline void input_sync(struct input_dev *dev) | |
| 参数 | struct input_dev *dev | 需要上报的 input_dev |
| 返回值 | ||
| 功能 | 告诉 Linux 内核 input 子系统上报结束，input_sync 函数本质是上报一个同步事件 | |
430 static inline void input_sync(struct input_dev *dev)
431 {
432 input_event(dev, EV_SYN, SYN_REPORT, 0);
433 } 3.7 input_set_capability
| 函数原型 | void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code) | |
| 参数 | struct input_dev *dev | 输入设备结构体指针 |
| unsigned int type | 输入事件的类型 | |
| unsigned int code | 事件的特定代码 | |
| 返回值 | ||
| 功能 | 向一个已注册的输入设备添加特定的输入能力 | |
1964 void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
1965 {
1966 switch (type) {
1967 case EV_KEY:
1968 __set_bit(code, dev->keybit);
1969 break;
1970
1971 case EV_REL:
1972 __set_bit(code, dev->relbit);
1973 break;
1974
1975 case EV_ABS:
1976 input_alloc_absinfo(dev);
1977 if (!dev->absinfo)
1978 return;
1979
1980 __set_bit(code, dev->absbit);
1981 break;
1982
1983 case EV_MSC:
1984 __set_bit(code, dev->mscbit);
1985 break;
1986
1987 case EV_SW:
1988 __set_bit(code, dev->swbit);
1989 break;
1990
1991 case EV_LED:
1992 __set_bit(code, dev->ledbit);
1993 break;
1994
1995 case EV_SND:
1996 __set_bit(code, dev->sndbit);
1997 break;
1998
1999 case EV_FF:
2000 __set_bit(code, dev->ffbit);
2001 break;
2002
2003 case EV_PWR:
2004 /* do nothing */
2005 break;
2006
2007 default:
2008 pr_err("%s: unknown type %u (code %u)\n", __func__, type, code);
2009 dump_stack();
2010 return;
2011 }
2012
2013 __set_bit(type, dev->evbit);
2014 }4 input.c分析
4.1 注册字符设备
input 核心层会向 Linux 内核注册一个字符设备，class_register函数注册一个 input 类，这样系统启动以后就会在/sys/class 目录下有一个 input 子目录
zwzn2064@zwzn2064-CVN-Z690D5-GAMING-PRO:~$ ls /sys/class
ata_device devfreq-event i2c-dev nvme printer scsi_generic vc
ata_link dma input nvme-subsystem ptp scsi_host vfio
ata_port dmi iommu pci_bus pwm sound virtio-ports
backlight extcon leds pci_epc rapidio_port spi_master vtconsole
bdi firmware mdio_bus phy regulator spi_slave wakeup
block gpio mem powercap remoteproc thermal watchdog
bsg graphics misc power_supply rfkill tpm wmi_bus
dax hidraw mmc_host ppdev rtc tpmrm
devcoredump hwmon nd ppp scsi_device tty
devfreq i2c-adapter net pps scsi_disk usbmisc
zwzn2064@zwzn2064-CVN-Z690D5-GAMING-PRO:~$ ls /sys/class/input/
event0 event11 event3 event6 event9 input10 input2 input5 input8
event1 event12 event4 event7 input0 input11 input3 input6 input9
event10 event2 event5 event8 input1 input12 input4 input7 mice
zwzn2064@zwzn2064-CVN-Z690D5-GAMING-PRO:~$ 代码如下所示
#define INPUT_MAJOR 1336 #define INPUT_MAX_CHAR_DEVICES 1024
1777 static char *input_devnode(struct device *dev, umode_t *mode)
1778 {
1779 return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
1780 }
1782 struct class input_class = {
1783 .name = "input",
1784 .devnode = input_devnode,
1785 };
2476 static int __init input_init(void)
2477 {
2478 int err;
2479
2480 err = class_register(&input_class);
2481 if (err) {
2482 pr_err("unable to register input_dev class\n");
2483 return err;
2484 }
2485
2486 err = input_proc_init();
2487 if (err)
2488 goto fail1;
2489
2490 err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2491 INPUT_MAX_CHAR_DEVICES, "input");
2492 if (err) {
2493 pr_err("unable to register char major %d", INPUT_MAJOR);
2494 goto fail2;
2495 }
2496
2497 return 0;
2498
2499 fail2: input_proc_exit();
2500 fail1: class_unregister(&input_class);
2501 return err;
2502 }
2503
2504 static void __exit input_exit(void)
2505 {
2506 input_proc_exit();
2507 unregister_chrdev_region(MKDEV(INPUT_MAJOR, 0),
2508 INPUT_MAX_CHAR_DEVICES);
2509 class_unregister(&input_class);
2510 }
2511
2512 subsys_initcall(input_init);
2513 module_exit(input_exit);4.2 函数分析
4.2.1 class_register
| 函数原型 | #define class_register(class) \ ({ \ static struct lock_class_key __key; \ __class_register(class, &__key); \ }) int __class_register(struct class *cls, struct lock_class_key *key) | |
| 参数 | struct class *cls | 指向 class 结构体的指针，表示要注册的设备类 |
| struct lock_class_key *key | 指向 lock_class_key 结构体的指针，用于锁的调试和分类（通常用于锁的层次化管理） | |
| 返回值 | int | 成功：0 失败：错误码 |
| 功能 | 注册设备类 | |
146 int __class_register(struct class *cls, struct lock_class_key *key)
147 {
148 struct subsys_private *cp;
149 int error;
150
151 pr_debug("device class '%s': registering\n", cls->name);
152
153 cp = kzalloc(sizeof(*cp), GFP_KERNEL);
154 if (!cp)
155 return -ENOMEM;
156 klist_init(&cp->klist_devices, klist_class_dev_get, klist_class_dev_put);
157 INIT_LIST_HEAD(&cp->interfaces);
158 kset_init(&cp->glue_dirs);
159 __mutex_init(&cp->mutex, "subsys mutex", key);
160 error = kobject_set_name(&cp->subsys.kobj, "%s", cls->name);
161 if (error) {
162 kfree(cp);
163 return error;
164 }
165
166 /* set the default /sys/dev directory for devices of this class */
167 if (!cls->dev_kobj)
168 cls->dev_kobj = sysfs_dev_char_kobj;
169
170 #if defined(CONFIG_BLOCK)
171 /* let the block class directory show up in the root of sysfs */
172 if (!sysfs_deprecated || cls != &block_class)
173 cp->subsys.kobj.kset = class_kset;
174 #else
175 cp->subsys.kobj.kset = class_kset;
176 #endif
177 cp->subsys.kobj.ktype = &class_ktype;
178 cp->class = cls;
179 cls->p = cp;
180
181 error = kset_register(&cp->subsys);
182 if (error) {
183 kfree(cp);
184 return error;
185 }
186 error = class_add_groups(class_get(cls), cls->class_groups);
187 class_put(cls);
188 return error;
189 }4.2.2 dev_name
| 函数原型 | static inline const char *dev_name(const struct device *dev) | |
| 参数 | const struct device *dev | 指向 struct device 结构体的指针，该结构体表示一个设备实例 |
| 返回值 | const char * | 函数返回一个指向 const char 的指针，这个指针指向设备名称的字符串 |
| 功能 | 获取设备名称 | |
1132 static inline const char *dev_name(const struct device *dev)
1133 {
1134 /* Use the init name until the kobject becomes available */
1135 if (dev->init_name)
1136 return dev->init_name;
1137
1138 return kobject_name(&dev->kobj);
1139 }4.2.3 register_chrdev_region
| 函数原型 | int register_chrdev_region(dev_t from, unsigned count, const char *name) | |
| 参数 | dev_t from | dev_t from: 起始设备号，指定从哪个设备号开始分配。 |
| unsigned count | unsigned count: 设备号的数量，指定需要多少个连续的设备号 | |
| const char *name | const char *name: 设备的名称，通常用于在系统中标识这个设备 | |
| 返回值 | int | 成功：字符设备分配设备号 失败：负值 |
| 功能 | 注册字符设备号 | |
209 int register_chrdev_region(dev_t from, unsigned count, const char *name)
210 {
211 struct char_device_struct *cd;
212 dev_t to = from + count;
213 dev_t n, next;
214
215 for (n = from; n < to; n = next) {
216 next = MKDEV(MAJOR(n)+1, 0);
217 if (next > to)
218 next = to;
219 cd = __register_chrdev_region(MAJOR(n), MINOR(n),
220 next - n, name);
221 if (IS_ERR(cd))
222 goto fail;
223 }
224 return 0;
225 fail:
226 to = n;
227 for (n = from; n < to; n = next) {
228 next = MKDEV(MAJOR(n)+1, 0);
229 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
230 }
231 return PTR_ERR(cd);
232 }4.2.3 MKDEV
| 函数原型 | #define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi)) #define MINORBITS 20 | |
| 参数 | ma | 主设备号 |
| mi | 此设备号 | |
| 返回值 | ||
| 功能 | 将主设备号和次设备号组合成一个 dev_t 类型的设备号 | |
5 示例
5.1 示例 1
5.1.1 代码
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/input.h>
struct input_dev *input_dev_s;
static int test_init(void)
{
int ret;
input_dev_s = input_allocate_device();
input_dev_s->name = "input_test";
input_dev_s->id.bustype = BUS_HOST;
input_dev_s->id.vendor = 0x0001;
input_dev_s->id.product = 0x0001;
input_dev_s->id.version = 0x0100;
ret = input_register_device(input_dev_s);
if(ret)
{
printk(KERN_ERR "register input device error\n");
input_free_device(input_dev_s);
goto failed;
}
printk("register input device ok\r\n");
return 0;
failed:
return ret;
}
static void test_exit(void)
{
printk("unregister input device\r\n");
input_unregister_device(input_dev_s);
}
module_init(test_init);
module_exit(test_exit);
MODULE_LICENSE("GPL");5.1.2 操作
注册成功后，/dev/input/下多了一个event4 文件节点
console:/data # ls /dev/input/
event0 event1 event2 event3
console:/data # insmod input_test.ko
[ 261.075255] input: input_test as /devices/virtual/input/input5
[ 261.077768] register input device ok
console:/data # ls /dev/input/
event0 event1 event2 event3 event4使用 cat /proc/bus/input/devices 命令查看输入设备信息，可以看到 input_test 的输入设备信息。
130|console:/data # cat /proc/bus/input/devices
I: Bus=0019 Vendor=524b Product=0006 Version=0100
N: Name="ff420030.pwm"
P: Phys=gpio-keys/remotectl
S: Sysfs=/devices/platform/ff420030.pwm/input/input0
U: Uniq=
H: Handlers=event0 cpufreq dmcfreq
B: PROP=0
B: EV=3
B: KEY=70010 20000000000000 0 100010002000000 78000004000a800 1e16c000000000 10004ffc
I: Bus=0019 Vendor=0001 Product=0001 Version=0100
N: Name="adc_keys"
P: Phys=adc-keys/input0
S: Sysfs=/devices/platform/adc_keys/input/input1
U: Uniq=
H: Handlers=event1 cpufreq dmcfreq
B: PROP=0
B: EV=3
B: KEY=c000000000000 0
I: Bus=0019 Vendor=0001 Product=0001 Version=0100
N: Name="gpio-keys"
P: Phys=gpio-keys/input0
S: Sysfs=/devices/platform/gpio-keys/input/input2
U: Uniq=
H: Handlers=event2 cpufreq dmcfreq
B: PROP=0
B: EV=100003
B: KEY=10000000000000 0
I: Bus=0000 Vendor=0001 Product=0001 Version=0100
N: Name="rk-headset"
P: Phys=
S: Sysfs=/devices/platform/rk-headset/input/input3
U: Uniq=
H: Handlers=event3
B: PROP=0
B: EV=3
B: KEY=400000000 0 0 0
I: Bus=0019 Vendor=0001 Product=0001 Version=0100
N: Name="input_test"
P: Phys=
S: Sysfs=/devices/virtual/input/input5
U: Uniq=
H: Handlers=event4
B: PROP=0
B: EV=1
console:/data # 5.2 mcu_cec驱动分析
5.2.1 注册输入事件
657 static int mcu_cec_probe(struct i2c_client *client, const struct i2c_device_id *id)
658 {
659 int ret = 0;
660 int i;
661 struct mcu_cec *mcu_cec;
662 struct input_dev *input;
663 struct device_node *np = client->dev.of_node;
664 printk("%s: probe\n", __FUNCTION__);
665
666
667 mcu_cec = devm_kzalloc(&client->dev, sizeof(struct mcu_cec), GFP_KERNEL);
668 if (!mcu_cec)
669 return -ENOMEM;
705 mcu_cec->mcu_cec_wq = create_singlethread_workqueue("mcu_cec_wq");
706 if (!mcu_cec->mcu_cec_wq){
707 printk(KERN_ERR"%s: create workqueue failed\n", __func__);
708 ret = -ENOMEM;
709 goto failed;
710 }
711
728 input = devm_input_allocate_device(&client->dev);
729 if (!input) {
730 ret = -ENOMEM;
731 goto failed;
732 }
733
736 input->name = client->name;
737 input->phys = "cec-keys/input0";
738 input->dev.parent = &client->dev;
739
740 input->id.bustype = BUS_HOST;
741 input->id.vendor = 0x0001;
742 input->id.product = 0x0001;
743 input->id.version = 0x0100;
744
745 mcu_cec->input_dev = input;
746
747 for (i=0;i<sizeof(mcu_cec_input_key)/sizeof(struct mcu_cec_key_table);i++){
748 unsigned int type = EV_KEY;
749
750 input_set_capability(input, type, mcu_cec_input_key[i].keyCode);
751 }
752 input_set_capability(input, EV_KEY, KEY_WAKEUP);
753 input_set_capability(input, EV_KEY, KEY_F12);
754 ret = input_register_device(input);
755 if (ret) {
756 input_free_device(input);
757 goto failed;
758 }
760 mcu_cec->nb.notifier_call = cec_hotplug_notifier_call;
761 ret = cec_hotplug_reg_notifier(&mcu_cec->nb);
762 if (ret) {
763 printk("failed to reg notifier: %d\n", ret);
764 }
765
766 mutex_init(&mcu_cec->m_lock);
767 wake_lock_init(&mcu_cec->w_lock, WAKE_LOCK_SUSPEND, "mcu_lock");
768 wake_lock(&mcu_cec->w_lock);
769 printk("%s: probe ok!!\n", __FUNCTION__);
770 return 0;
771 failed:
772 return ret;
773 }5.2.2 函数分析
5.2.2.1 devm_input_allocate_device
| 函数原型 | struct input_dev *devm_input_allocate_device(struct device *dev) | |
| 参数 | struct device *dev | 设备结构体指针 |
| 返回值 | struct input_dev * | 输入设备结构体指针 |
| 功能 | 分配并初始化一个输入设备 | |
1862 struct input_dev *devm_input_allocate_device(struct device *dev)
1863 {
1864 struct input_dev *input;
1865 struct input_devres *devres;
1866
1867 devres = devres_alloc(devm_input_device_release,
1868 sizeof(*devres), GFP_KERNEL);
1869 if (!devres)
1870 return NULL;
1871
1872 input = input_allocate_device();
1873 if (!input) {
1874 devres_free(devres);
1875 return NULL;
1876 }
1877
1878 input->dev.parent = dev;
1879 input->devres_managed = true;
1880
1881 devres->input = input;
1882 devres_add(dev, devres);
1883
1884 return input;
1885 }1834 static void devm_input_device_release(struct device *dev, void *res)
1835 {
1836 struct input_devres *devres = res;
1837 struct input_dev *input = devres->input;
1838
1839 dev_dbg(dev, "%s: dropping reference to %s\n",
1840 __func__, dev_name(&input->dev));
1841 input_put_device(input);
1842 }devm_input_allocate_device 函数提供了一个方便的方式来分配和初始化 input_dev 设备，并利用设备管理机制自动处理资源释放。这使得设备的创建和销毁变得更加简洁和安全。
devres 机制: devres（设备资源）用于管理与设备相关的资源。devres_add 将资源添加到设备的资源管理列表中，devm_input_device_release 函数会在设备释放时调用，以释放相关资源。
自动资源管理: 通过 devres 机制，确保在设备卸载时，input_dev 设备会被正确释放，避免内存泄漏和资源浪费。
父设备设置: 将 input_dev 的父设备设置为传入的设备 dev，确保设备之间的关系正确设置，有利于设备树的管理和资源的分配。
5.2.3 上报事件
90 static struct mcu_cec_key_table mcu_cec_input_key[] = {
91 {0x40, KEY_POWER}, //power off
92 {0x30, KEY_POWER}, //power off
93 {0x01, KEY_UP},
94 {0x02, KEY_DOWN},
95 {0x03, KEY_LEFT},
96 {0x04, KEY_RIGHT},
97 {0x41, KEY_VOLUMEUP},
98 {0x42, KEY_VOLUMEDOWN},
99 {0x43, KEY_BACK}, //mute
100 {0x2b, KEY_ENTER},
101 {0x20, KEY_0},
102 {0x21, KEY_1},
103 {0x22, KEY_2},
104 {0x23, KEY_3},
105 {0x24, KEY_4},
106 {0x25, KEY_5},
107 {0x26, KEY_6},
108 {0x27, KEY_7},
109 {0x28, KEY_8},
110 {0x29, KEY_9},
111 {0x2a, KEY_DOT},
112 {0xd, KEY_BACK},
113 {0x48, KEY_REWIND},
114 {0x46, KEY_PLAYPAUSE},
115 {0x49, KEY_FASTFORWARD},
116 {0x44, KEY_PLAYPAUSE},
117 {0x45, KEY_STOP},
118 {0x71, KEY_MENU},//KEY_BLUE
119 {0x74, KEY_HOME},//KEY_YELLOW KEY_HOME
120 {0xa, KEY_MENU},//KEY_BLUE
121 {0x09, KEY_HOME},//KEY_YELLOW KEY_HOME
122 {0x4b, KEY_NEXTSONG},
123 {0x4c, KEY_PREVIOUSSONG},
124 };
127 static unsigned char cec_get_keycode(unsigned char cecCode)
128 {
129 int i;
130
131 for (i = 0; i < sizeof(mcu_cec_input_key)/sizeof(struct mcu_cec_key_table); i++){
132 if (mcu_cec_input_key[i].cecCode == cecCode){
133 return mcu_cec_input_key[i].keyCode;
134 }
135 }
136 return 0;
137 }
426 static void mcu_cec_report_standby_task(struct work_struct *work)
427 {
428 int ret;
429 unsigned char ceckey;
430 unsigned char keyCode;
431 cec_int_status mcu_value;
432 struct mcu_cec *mcu_cec = container_of(work, struct mcu_cec, work);
433 mutex_lock(&mcu_cec->m_lock);
434 ret = regmap_read(mcu_cec->regmap, CEC_INT_STATUS, (int *)&mcu_value.status);
435 if (ret) {
436 dev_err(&mcu_cec->i2c->dev, "read 0x%x failed\n", CEC_INT_STATUS);
437 goto failed;
438 }
439 if(mcu_value.status_bit.req_standby == 1){
440 mcu_value.status_bit.req_standby = 0;
441 ret = regmap_write(mcu_cec->regmap, CEC_INT_STATUS, (unsigned int)mcu_value.status);
442 if (ret) {
443 dev_err(&mcu_cec->i2c->dev, "write 0x%x failed\n", CEC_INT_STATUS);
444 }
445 input_event(mcu_cec->input_dev, EV_KEY, KEY_F12, 1);
446 input_sync(mcu_cec->input_dev);
447 input_event(mcu_cec->input_dev, EV_KEY, KEY_F12, 0);//KEY_WAKEUP
448 input_sync(mcu_cec->input_dev);
449 pr_err("report host stanby\n");
450 }else if(mcu_value.status_bit.remote_control == 1){
451 mcu_value.status_bit.remote_control = 0;
452 ret = regmap_write(mcu_cec->regmap, CEC_INT_STATUS, (unsigned int)mcu_value.status);
453 if (ret) {
454 dev_err(&mcu_cec->i2c->dev, "write 0x%x failed\n", CEC_INT_STATUS);
455 }
456
457 ret = regmap_read(mcu_cec->regmap, CEC_REMOTE_KEY, (unsigned int *)&ceckey);
458 if (ret) {
459 dev_err(&mcu_cec->i2c->dev, "read 0x%x failed\n", CEC_INT_STATUS);
460 goto failed;
461 }
462
463 keyCode = cec_get_keycode(ceckey);
464
465 {
466 mcu_cec->keycode = keyCode;
467 if (mcu_cec->keycode == KEY_POWER)
468 {
469 if(mcu_cec->input_dev){
470 input_event(mcu_cec->input_dev, EV_KEY, KEY_POWER, 1);
471 input_sync(mcu_cec->input_dev);
472 input_event(mcu_cec->input_dev, EV_KEY, KEY_POWER, 0);//KEY_WAKEUP
473 input_sync(mcu_cec->input_dev);
474 }
475 }else {
476 input_event(mcu_cec->input_dev, EV_KEY, mcu_cec->keycode, 1);
477 input_sync(mcu_cec->input_dev);
478 input_event(mcu_cec->input_dev, EV_KEY, mcu_cec->keycode, 0);
479 input_sync(mcu_cec->input_dev);
480 }
481 }
482
483
484 // report_cec_input_keycode(mcu_cec);
485 }
486 enable_irq(mcu_cec->i2c->irq);
487 failed:
488 mutex_unlock(&mcu_cec->m_lock);
489
490 }
