Linux 驱动USB键盘驱动入门demo

最新推荐文章于 2023-08-26 09:39:56 发布
最新推荐文章于 2023-08-26 09:39:56 发布
阅读量408 收藏
点赞数
分类专栏： 内核4.4.194 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oHeHui1/article/details/127701361
版权

1 需要内核配置文件禁用CONFIG_USB_HID，不然下面的驱动不会被探测到。
2 以下模块打印了8个控制按键是否被按下，
另外如果A按键按下，也会有打印。

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/usb.h>
#include <linux/slab.h>
#include <linux/timer.h>
#include <linux/usb/storage.h>
#include <scsi/scsi_proto.h>
#include <asm-generic/errno-base.h>
#include <uapi/asm-generic/errno.h>
#include <uapi/linux/cciss_defs.h>
#include <linux/usb/input.h>
#include <linux/hid.h>

/**


 *
 */

#define USB_VENDOR_ID   0x413c
#define USB_PRODUCT_ID  0x2113

#define PRINT_USB_ENDPOINT_DESCRIPTOR( i )                         \
{                                                                   \
    pr_info("USB_INTERFACE_DESCRIPTOR:\n");                         \
    pr_info("-----------------------------\n");                     \
    pr_info("bLength: 0x%x\n", i.bLength);                          \
    pr_info("bDescriptorType: 0x%x\n", i.bDescriptorType);          \
    pr_info("bInterfaceNumber: 0x%x\n", i.bInterfaceNumber);        \
    pr_info("bAlternateSetting: 0x%x\n", i.bAlternateSetting);      \
    pr_info("bNumEndpoints: 0x%x\n", i.bNumEndpoints);              \
    pr_info("bInterfaceClass: 0x%x\n", i.bInterfaceClass);          \
    pr_info("bInterfaceSubClass: 0x%x\n", i.bInterfaceSubClass);    \
    pr_info("bInterfaceProtocol: 0x%x\n", i.bInterfaceProtocol);    \
    pr_info("iInterface: 0x%x\n", i.iInterface);                    \
    pr_info("\n");                                                  \
}

static const unsigned char usb_kbd_keycode[256] = {
	  0,  0,  0,  0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
	 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44,  2,  3,
	  4,  5,  6,  7,  8,  9, 10, 11, 28,  1, 14, 15, 57, 12, 13, 26,
	 27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
	 65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
	105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
	 72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
	191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
	115,114,  0,  0,  0,121,  0, 89, 93,124, 92, 94, 95,  0,  0,  0,
	122,123, 90, 91, 85,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	 29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
	150,158,159,128,136,177,178,176,142,152,173,140
};

struct usb_device *usb_dev;

struct vdsk_dev {
	unsigned long size;
	u8 *data;
	spinlock_t lock;
	struct gendisk *mydisk;
	struct request_queue *queue;
};

u8 *buffer;

static void usb_mouse_irq(struct urb *urb) {
	int i;
//	pr_info("usb_mouse_irq \n");
//	pr_info("BTN_LEFT %x \n", (*buffer) & 0x01);

	if((buffer[0] >> 0) & 1){
		pr_info("left ctrl pressed\n");
i=0;
pr_info("keycode = %d\n",usb_kbd_keycode[i + 224]);

	}
	if((buffer[0] >> 1) & 1){
		i=1;
			pr_info("left shift pressed\n");
			pr_info("keycode = %d\n",usb_kbd_keycode[i + 224]);



		}
	if((buffer[0] >> 2) & 1){
				pr_info("left alt pressed\n");
				i=2;
				pr_info("keycode = %d\n",usb_kbd_keycode[i + 224]);
			}
	if((buffer[0] >> 3) & 1){
					pr_info("KEY_LEFTMETA pressed\n");
					i=3;
					pr_info("keycode = %d\n",usb_kbd_keycode[i + 224]);

				}

	if((buffer[0] >> 4) & 1){
						pr_info("right ctrl  pressed\n");
						i=4;
						pr_info("keycode = %d\n",usb_kbd_keycode[i + 224]);
					}

	if((buffer[0] >> 5) & 1){
							pr_info("right shift  pressed\n");
							i=5;
							pr_info("keycode = %d\n",usb_kbd_keycode[i + 224]);
						}

	if((buffer[0] >> 6) & 1){
								pr_info("right alt  pressed\n");
								i=6;
								pr_info("keycode = %d\n",usb_kbd_keycode[i + 224]);
							}

	for (i = 0; i < 8; i++){
//		pr_info("BTN_LEFT %x \n", (buffer[0] >> i) & 1);
	}
//			input_report_key(kbd->dev, usb_kbd_keycode[i + 224], (kbd->new[0] >> i) & 1);


	for (i = 2; i < 8; i++) {
	if (buffer[i] > 3 ) {
			pr_info("i = %d\n",i);
				if (usb_kbd_keycode[buffer[i]]){
					pr_info("keycode = %d\n",usb_kbd_keycode[buffer[i]]);
					if(usb_kbd_keycode[buffer[i]] == KEY_A){
						pr_info("A pressed\n");
					}

				}

	}
			}


	 usb_submit_urb(urb,GFP_ATOMIC);
}

struct vdsk_dev *dev;

int usb_mouse_probe(struct usb_interface *interface,
		const struct usb_device_id *id) {
	struct urb  *irq;
	int endpoint_int_in_addr;
	unsigned int i;
	unsigned int endpoints_count;
	int endpoint_type;
	struct usb_endpoint_descriptor endpoint;
	int interfaceClass;
	int interfaceSubClass;
	int interfaceProtocol;
	int pipe, maxp;

	struct usb_host_interface *iface_desc = interface->cur_altsetting;

	usb_dev = interface_to_usbdev(interface);
	buffer = kmalloc(8,GFP_KERNEL);

	dev_info(&interface->dev, "myprobe start\n");
	dev_info(&interface->dev, "idVendor = %x\n", id->idVendor);
	dev_info(&interface->dev, "idProduct = %x\n", id->idProduct);

	endpoints_count = iface_desc->desc.bNumEndpoints;
	dev_info(&interface->dev, "endpoints_count = %d\n", endpoints_count);

	interfaceClass = iface_desc->desc.bInterfaceClass;

	interfaceSubClass = iface_desc->desc.bInterfaceSubClass;

	interfaceProtocol = iface_desc->desc.bInterfaceProtocol;

	dev_info(&interface->dev, "bInterfaceClass = 0x%x\n", interfaceClass);

	dev_info(&interface->dev, "interfaceSubClass = 0x%x\n", interfaceSubClass);

	dev_info(&interface->dev, "interfaceProtocol = 0x%x\n", interfaceProtocol);

	if (iface_desc->desc.bNumEndpoints < 1)
		return -ENODEV;

	switch (interfaceClass) {
	case USB_CLASS_HID:
		dev_info(&interface->dev, "interfaceClass: USB_CLASS_HID\n");
		break;
	case USB_CLASS_MASS_STORAGE:
		dev_info(&interface->dev, "interfaceClass: USB_CLASS_MASS_STORAGE\n");
		break;
	default:
		dev_info(&interface->dev, "never \n");
		break;
	}

	switch (interfaceSubClass) {
	case USB_SC_SCSI:
		dev_info(&interface->dev, "interfaceSubClass: USB_SC_SCSI\n");
		break;
	default:
		dev_info(&interface->dev, "never \n");
		break;
	}

	switch (interfaceProtocol) {
	case USB_PR_BULK:
		dev_info(&interface->dev, "interfaceProtocol: USB_PR_BULK\n");
		break;
	default:
		dev_info(&interface->dev, "never \n");
		break;
	}

	endpoint = iface_desc->endpoint[0].desc;

		if (usb_endpoint_is_int_in(&endpoint)) {
			endpoint_int_in_addr = endpoint.bEndpointAddress;
		}

		dev_info(&interface->dev, "endpoint %d bDescriptorType = %d\n", i,
				endpoint.bDescriptorType);

		dev_info(&interface->dev, "endpoint %d bEndpointAddress = %d\n", i,
				endpoint.bEndpointAddress);

		dev_info(&interface->dev, "endpoint %d bInterval = %d\n", i,
				endpoint.bInterval);

		pipe = usb_rcvintpipe(usb_dev, endpoint.bEndpointAddress);

		maxp = usb_maxpacket(usb_dev, pipe,0);

		endpoint_type = endpoint.bmAttributes
				& USB_ENDPOINT_XFERTYPE_MASK;

		switch (endpoint_type) {
		case USB_ENDPOINT_XFER_CONTROL:
			dev_info(&interface->dev, "control endpoint\n");
			break;
		case USB_ENDPOINT_XFER_ISOC:
			dev_info(&interface->dev, "ISOCHRONOUS endpoint\n");
			break;
		case USB_ENDPOINT_XFER_BULK:
			dev_info(&interface->dev, "bulk endpoint\n");
			break;
		case USB_ENDPOINT_XFER_INT:
			dev_info(&interface->dev, "Interrupt  endpoint\n");
			break;
		default:
			dev_info(&interface->dev, "never \n");
			break;
		}
	dev_info(&interface->dev, "myprobe end\n");

irq =	usb_alloc_urb(0, GFP_KERNEL);

usb_fill_int_urb(irq, usb_dev, pipe, buffer,
			 (maxp > 8 ? 8 : maxp),
			 usb_mouse_irq, NULL, endpoint.bInterval);


 usb_submit_urb(irq,GFP_ATOMIC);

	return 0;
}

void usb_mouse_disconnect(struct usb_interface *intf) {
	dev_info(&intf->dev, "mydisconnect\n");
}

//static struct usb_device_id usb_mouse_id_table[] = { { USB_INTERFACE_INFO(
//		USB_CLASS_HID,
//0, 0) }, { } };

//static struct usb_device_id usb_mouse_id_table[] = { { USB_DEVICE(USB_VENDOR_ID,
//USB_PRODUCT_ID) }, { } };

static struct usb_device_id usb_kbd_id_table [] = {
	{ USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
		USB_INTERFACE_PROTOCOL_KEYBOARD) },
	{ }						/* Terminating entry */
};


MODULE_DEVICE_TABLE(usb, usb_kbd_id_table);


static struct usb_driver usb_mouse_driver  = { .name = "andy_mouse_driver", .probe =
		usb_mouse_probe, .disconnect = usb_mouse_disconnect, .id_table =
				usb_kbd_id_table, };

module_usb_driver( usb_mouse_driver );

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Andy");
hehui0921
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 自带按键驱动
weixin_46829095的博客
02-28 1092
Linux 自带按键驱动及其设备树节点编写
内核编译图文教程，usb键盘鼠标篇
linux-0.11调试教程
02-10 2632
CONFIG_INPUT_MOUSEDEV CONFIG_INPUT_EVDEV Hardware I/O ports什么都不用选 CONFIG_USB_HID To compile this driver as a module, choose M here: the module will be called usbhid. Depends on: USB [=y]
嵌入式linux下如何使用usb键盘
最新发布
u010584870的博客
08-26 897
(注意：有可能默认设置USB键盘驱动是不可见的，需修改当前目录下的Kconfig文件)uImage生成后位于目录：arch/arm/boot/uImage;(或者直接将usb键盘驱动编译为驱动模块，进行加载也可)；操作usb键盘，会有乱码出现；
Linux USB 驱动实验
zhuguanlin121的博客
03-29 3482
USB 接口简介 什么是USB？ USB 电气特性 USB 拓扑结构 什么是USB OTG？ I.MX6ULL USB 接口简介 硬件原理图分析 USB HUB 原理图分析 V2.4 版本以前底板USB OTG 原理图分析 V2.4 及以后版本底板USB OTG 原理图分析 USB 协议简析 USB 描述符 USB 数据包类型 USB 传输类型 USB 枚举 Linux 内核自带HOST 实验 USB 鼠标键盘测试 U 盘实验 Linux 内核自带USB OTG 实验 修改设备树 OTG 主机实验 OTG
linux按键驱动(input子系统)
Calmer_的博客
02-14 667
linux按键驱动(input子系统)
嵌入式Linux驱动程序设计从入门到精通.part01.rar
03-11
button.c 键盘驱动 CHA4 Linux内核I2C驱动 CHA5 usb-skeleton.c USB驱动框架 camera Spcaview相关代码 CHA6 skeleton FrameBuffer驱动框架 2410fb.c S3C2410X LCD驱动 CHA7 button.c 输入形式的按键驱动 LED.c ...
嵌入式Linux驱动程序设计从入门到精通.part04.rar
03-11
button.c 键盘驱动 CHA4 Linux内核I2C驱动 CHA5 usb-skeleton.c USB驱动框架 camera Spcaview相关代码 CHA6 skeleton FrameBuffer驱动框架 2410fb.c S3C2410X LCD驱动 CHA7 button.c 输入形式的按键驱动 LED.c 输入...
嵌入式Linux驱动程序设计从入门到精通.part02.rar
03-11
button.c 键盘驱动 CHA4 Linux内核I2C驱动 CHA5 usb-skeleton.c USB驱动框架 camera Spcaview相关代码 CHA6 skeleton FrameBuffer驱动框架 2410fb.c S3C2410X LCD驱动 CHA7 button.c 输入形式的按键驱动 LED.c ...
嵌入式Linux驱动程序设计从入门到精通.part06.rar
03-11
button.c 键盘驱动 CHA4 Linux内核I2C驱动 CHA5 usb-skeleton.c USB驱动框架 camera Spcaview相关代码 CHA6 skeleton FrameBuffer驱动框架 2410fb.c S3C2410X LCD驱动 CHA7 button.c 输入形式的按键驱动 LED.c 输入...
嵌入式Linux驱动程序设计从入门到精通.part09.rar
03-11
button.c 键盘驱动 CHA4 Linux内核I2C驱动 CHA5 usb-skeleton.c USB驱动框架 camera Spcaview相关代码 CHA6 skeleton FrameBuffer驱动框架 2410fb.c S3C2410X LCD驱动 CHA7 button.c 输入形式的按键驱动 LED.c 输入...
Linux下的硬件驱动——USB设备（上）（驱动配置部分）
小伟
11-02 4185
赵明(carl__zhao@163.com) 联想软件设计中心嵌入式研发处系统设计工程师 2003年7月 USB设备越来越多，而Linux在硬件配置上仍然没有做到完全即插即用，对于Linux怎样配置和使用他们，也越来越成为困扰我们的一大问题。本文分两部分着力从Linux系统下设备驱动的架构，去阐述怎样去使用和配置以及怎样编制USB设备驱动。对于一般用户，可以使我们明晰Linux设备驱动方式，为更好
Linux键盘驱动范例
杨德龙的专栏
04-21 1461
键盘在所有的驱动之中最为简单的一种，但它却包含了驱动的基本框架，对以后继续深入学习其他复杂的驱动大有裨益，以下便为你逐步剖析驱动的开发。采用的是查询方式。转载请注明出处：qiangren.blog.edu.cn  一.内核模块的注册和撤销在加载模块的时候，首先运行的是内核模块的注册函数。它的功能包括内核注册设备以及变量的初始化。static int head,tail;int  _init
linux下usb驱动头文件的usb.h(二)
landishu的专栏
09-19 1901
http://blog.zol.com.cn/4494/article_4493001.html #define URB_NO_FSBR 0x0020 /* UHCI-specific */ 　　#define URB_ZERO_PACKET 0x0040 /* 完成大块分解成小包输出 　　#define URB_NO_INTERRUPT 0x0080 /* HINT: no n
libusb开发指南
热门推荐
ARM-Linux
10-07 2万+
libusb分析及使用指南
Linux下的USB总线驱动(04)——USB键盘驱动 usbkbd.c
Incanus's Blog
01-12 2946
原文链接地址：http://www.linuxidc.com/Linux/2012-12/76197p9.htm 跟USB鼠标类型一样，USB键盘也属于HID类型，代码在/dirver/hid/usbhid/usbkbd.c下。USB键盘除了提交中断URB外，还需要提交控制URB。不多话，我们看代码 static int __init usb_kbd_init(void) { int
USB驱动——键盘驱动（控制传输）
漫不经心
07-21 5546
本文以 usbkbd.c 为例，分析 usb 键盘驱动程序。 static int __init usb_kbd_init(void) { int result = usb_register(&usb_kbd_driver); if (result == 0) printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" DRIV
Linux kernel: USB driver编写入门（一）
qq_42000667的博客
07-18 2276
Linux Kernel的usb驱动程序最基础框架编写，能实现加载(load)/注册(register)和卸载(unload)/注销(deregister）。适合于初学Linux驱动人士。
Linux2.6.34下 USB驱动（U盘\USB鼠标、键盘）
老徐2014
08-13 6771
由于Linux中对USB的驱动已经非常完善，这里只需要按照以下配置  就可以了，配置完后重新编译内核烧到开发板上 1、修改make menuconfig        System Type -->      S3C2410 USB function support
Linux驱动demo
06-03
以下是一个简单的Linux驱动程序示例，它创建了一个名为“hello”的字符设备，并实现了读取和写入设备的功能： ```c #include <linux/module.h> #include <linux/fs.h> #include <linux/uaccess.h> #define DEVICE_NAME "hello" #define BUF_LEN 80 MODULE_LICENSE("GPL"); static int major; // 设备号 static char msg[BUF_LEN]; // 设备缓冲区 static char *msg_ptr; static int hello_open(struct inode *inode, struct file *file) { msg_ptr = msg; return 0; } static ssize_t hello_read(struct file *file, char *buf, size_t count, loff_t *pos) { int bytes_read = 0; while (count && *msg_ptr) { put_user(*(msg_ptr++), buf++); count--; bytes_read++; } return bytes_read; } static ssize_t hello_write(struct file *file, const char *buf, size_t count, loff_t *pos) { int i; for (i = 0; i < count && i < BUF_LEN; i++) { get_user(msg[i], buf + i); } msg_ptr = msg; return i; } static const struct file_operations fops = { .owner = THIS_MODULE, .read = hello_read, .write = hello_write, .open = hello_open, }; static int __init hello_init(void) { major = register_chrdev(0, DEVICE_NAME, &fops); if (major < 0) { printk(KERN_ALERT "Failed to register device\n"); return major; } printk(KERN_INFO "Hello device registered, major = %d\n", major); return 0; } static void __exit hello_exit(void) { unregister_chrdev(major, DEVICE_NAME); printk(KERN_INFO "Goodbye\n"); } module_init(hello_init); module_exit(hello_exit); ``` 在此示例中，我们定义了一个名为“hello”的字符设备，并实现了读取和写入设备的功能。我们使用`register_chrdev`函数注册设备，并在`hello_read`和`hello_write`函数中实现读取和写入设备的功能。最后，我们使用`module_init`和`module_exit`函数来初始化和退出驱动程序。 该示例只是一个简单的Linux驱动程序示例，它可以作为了解驱动程序开发的起点。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值