Bài tập lớn lập trình driver trên ubuntu 32 bit chương 2 viết driver cho ubuntu 32bi

BAN CƠ YẾU CHÍNH PHỦ HỌC VIỆN KỸ THUẬT MẬT Mà ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ BÀI TẬP LỚN LẬP TRÌNH DRIVER TRÊN UBUNTU 32 BIT Mơn học: Lập trình driver Lớp: CT0201 Nhóm sinh viên thực hiện: Phạm Bá Hiếu Nguyễn Tuấn Anh Người hướng dẫn: TS Phạm Văn Hưởng Khoa Công nghệ thông tin – Học viện Kỹ thuật Mật Mã Hà Nội, 2020 Mục lục MỞ ĐẦU Chương KIẾN THỨC NỀN TẢNG 1.1 Hệ điều hành Ubuntu .4 1.1.1 Khái niệm .4 1.2 Ubuntu 32 bit Ubuntu 64 bit .4 1.2.1 Kiến trúc HĐH Ubuntu 1.2.2 Cài đặt hệ điều hành Ubuntu .6 1.3 Driver 10 1.3.1 Khái niệm 10 1.3.2 Môi trường, công cụ quy trình biên dịch Driver 13 Chương Viết driver cho ubuntu 32bit 14 2.1 Kiến thức ngôn ngữ C/C++ 14 2.1.1 Khái niệm 14 2.1.2 Cú pháp C 14 2.1.3 Lưu liệu 15 2.2 Lập trình driver ubuntu 16 2.3 Phát triển driver cho bàn phím usb 17 2.3.1 Mơ tả chương trình mã nguồn 17 2.3.2 Truyền liệu USB thiết bị 18 2.3.3 Phân tích mã Drive 20 2.3.4 Xử lý urb trình device driver 22 2.3.5 Mã nguồn usb driver 24 KẾT LUẬN 33 TÀI LIỆU THAM KHẢO 34 MỞ ĐẦU Hiện nay, với phát triển ngày nhanh hệ thống nhúng thị trường, dễ dàng thấy hệ điều hành Linux xuất hầu hết tạp khả đáp ứng cao Việc tích hợp hệ điều hành lên hệ giản hóa q trình thiết kế sản phẩm, rút ngắn thời gian chi phí ứng dụng kế thừa ưu việt hệ điều hành nói riêng Đó nhỏ gọn, ổn định, thực thi nhanh, đơn giản hóa khả n phần cứng Hơn nữa, với cộng đồng sử dụng Linux rộng lớn phần mềm mã nguồn mở đa dạng làm cho việc phát triển hệ thống chiến lược công ty lựa chọn hàng đầu Mặt khác, chuẩn giao tiếp USB (Universal Series Bus) chuẩn giao tiếp phổ biến Hiện tại, USB trở thành chuẩn phương thức truyền liệu thân thuộc với người dùng công nghệ nhờ bền giá thành hợp lý Do chúng em định chọn đề tài “Viết driver bàn phím USB làm tập lớn cho mơn học Vì đề tài tương gian thực có hạn, nên nhóm chúng em dừng lại mức độ sâu hệ điều hành nhằm tìm hiểu chế quản lý giao tiếp USB Linux dụng nằm file /drivers/hid Linux kernel KIẾN THỨC NỀN TẢNG a) Hệ điều hành Ubuntu 1.a.1 Khái niệm Ubuntu hệ điều hành máy tính dựa Debian GNU/Linux, phân phối Linux thơng dụng Ubuntu có nhiều tính hữu ích cho máy tính xách tay, desktop máy chủ Đồng thời, hệ điều hành Ubuntu cung cấp miễn phí b) Ubuntu 32 bit Ubuntu 64 bit - Ubuntu 32 bit: sử dụng cho máy tính có CPU mà độ rộng ghi bên 32 bit - Hệ thống 32 bit truy cập địa nhớ, tức 4GB RAM hoăc nhớ vật lý Trong q trình sử dụng máy tính, ta sử dụng vượt dung lượng RAM hệ thống tự động chuyển sang sử dụng nhớ ảo hay dung lượng ổ cứng dư để lưu trữ tạm thời - Vi xử lý 32 bit tương thích với hệ điều hành 32 bit - Khơng phù hợp với stress testing multi-tasking - Ubuntu 64 bit: sử dụng cho máy tính có CPU mà độ rộng ghi bên 64 bit - Hệ thống 64 bit truy cập địa nhớ, tức 17 tỉ GB RAM Hệ thống phù hợp với bị có nhiều 4GB RAM - Vi xử lý 64 bit chạy hệ điều hành 32 bit 64 bit - Hoạt động tốt cho stress testing multi-tasking - Các phân phối Ubuntu:  Kubuntu phân phối Ubuntu để sử dụng môi trường làm việc KDE  Lubuntu phiên gọn nhẹ sử dụng LXDE, khuyên dùng cho máy tính cũ, cấu hình thấp  Xubuntu phân phối với giao diện mặc định Xfce  Myth ubuntu phân phối dành cho hệ thống kênh truyền hình MythTV, thích hợp cho giải trí gia đình  Ubuntu Studio tảng chuyên phục vụ chỉnh sửa video âm chuyên nghiệp, chất lượng cao - Yêu cầu thiết bị (phiên 20.04 TLS):  Vi xử lý tốc độ 2GHz, nhân  Ram 4Gb  25GB dung lượng đĩa trống 1.b.1 Kiến trúc HĐH Ubuntu 1.b.2 Cài đặt hệ điều hành Ubuntu Tải hệ điều hành Sử dụng chương trình Vmware Đặt tên máy ảo, vị trí lưu trữ: Cấu hình dung lượng ổ đĩa cho máy ảo: Cấu hình RAM cho máy ảo: - Bằng cách đánh giá trạng thái urb chức hồn chỉnh, bạn biết tình hình cụ thể urb hồn thành: 2.c.3 Phân tích mã Drive a) Khởi tạo usb - Cấu trúc usb_driver cần khởi tạo xác trước đăng ký trình điều khiển Có thành viên phải khởi tạo: b) thăm dò, ngắt kết nối - Chúng gọi thiết bị USB kết nối khớp với trình điều khiển thiết bị bị ngắt kết nối Khi thiết bị trình điều khiển khớp với nhau, cấu trúc usb_interface khởi tạo chuyển vào hàm porbe trình điều khiển - Các lệnh gọi lại chức thăm dò ngắt kết nối gọi ngữ cảnh luồng nhân trung tâm USB, chế độ ngủ chúng hợp pháp - Nguyên mẫu chức thăm dò chức ngắt kết nối trình điều khiển thiết bị USB sau: - Cơng việc hàm probe Phát địa điểm cuối kích thước đệm thiết bị khởi tạo cấu trúc liên quan đến điều khiển thiết bị USB Lưu cấu trúc thiết bị khởi tạo vào thiết bị giao diện Đăng ký thiết bị USB - Cơng việc hàm ngắt kết nối Giải phóng tất tài nguyên phân bổ cho thiết bị Đặt trỏ liệu thiết bị giao diện thành NULL Hủy đăng ký thiết bị USB - API liên quan /* linux/usb.h */ static inline void usb_set_intfdata(struct usb_interface *intf, void *data); static inline void *usb_get_intfdata(struct usb_interface *intf); /* drivers/usb/core/file.c */ int usb_register_dev(struct usb_interface *intf, struct usb_class_driver *class_driver); void usb_deregister_dev(struct usb_interface *intf, struct usb_class_driver *class_driver); /* linux/usb.h */ struct usb_class_driver { char *name; char *(*devnode)(struct device *dev, umode_t *mode); const struct file_operations *fops; int minor_base; }; - usb_class_driver sử dụng để định loại thiết bị thiết bị usb, chẳng hạn thiết bị ký tự, thiết bị đầu vào, thiết bị khối, thiết bị tty, v.v.; thiết bị ký tự, chức mở, đọc, ghi thành viên fops cấu trúc usb_class_driver có trạng thái chúng Chúng hồn tồn giống với thành viên cấu trúc tệp_operations; loại thiết bị khác, chức đăng ký tương ứng chúng gọi Nhưng thiết bị kết nối với bus USB việc truyền liệu chúng thực thông qua urb - usb_register_dev () khơng cần thiết, phải gọi trình điều khiển thiết bị sử dụng số thiết bị USB; tạo thư mục tương ứng hệ thống tệp sysfs theo usb_class_driver 2.c.4 Xử lý urb trình device driver - Từ phần "vịng đời urb" trước đó, biết trình xử lý urb trình điều khiển thiết bị bao gồm: tạo khởi tạo urb, gửi urb, hủy urb xử lý sau urb hoàn thành - Sau sử dụng ví dụ để minh họa trình urb xử lý trình điều khiển thiết bị: static int usb_kbd_alloc_mem(struct usb_device *dev, struct usb_kbd *kbd) { if (!(kbd->irq = usb_alloc_urb(0, GFP_KERNEL))) return -1; if (!(kbd->led = usb_alloc_urb(0, GFP_KERNEL))) return -1; if (!(kbd->new = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &kbd->new_dma))) return -1; if (!(kbd->cr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL))) return -1; if (!(kbd->leds = usb_alloc_coherent(dev, 1, GFP_ATOMIC, &kbd->leds_dma))) return -1; return 0; } - urb hoàn thành chức gọi lại Mã lỗi -ENOENT, -ECONNRESET, -ESHUTDOWN lỗi truyền thực mà báo cáo điều kiện kèm với q trình truyền thành cơng static int usb_kbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { unsigned long flags; struct usb_kbd *kbd = input_get_drvdata(dev); if (type != EV_LED) return -1; spin_lock_irqsave(&kbd->leds_lock, flags); // if (kbd->mode == 0) { if (((!!test_bit(LED_NUML, dev->led)) != (*(kbd->leds) & 1))&&((!! test_bit(LED_CAPSL, dev->led)) == 0)) { kbd->mode = 1; kbd->newleds = (!!test_bit(LED_KANA, dev->led) led) led) newleds = (!!test_bit(LED_KANA, dev->led) led) led) led) led)); } } else { if ((!!test_bit(LED_NUML, dev->led)) != (*(kbd->leds) & 1)) kbd->mode = 0; kbd->newleds = (!!test_bit(LED_KANA, dev->led) led) led) led) led)); printk("Now change to MODE 1\n"); } else { kbd->newleds = (!!test_bit(LED_KANA, dev->led) led) led) led) led)); } } // if (kbd->led_urb_submitted){ spin_unlock_irqrestore(&kbd->leds_lock, flags); return 0; } | (!! { | (!! | (!! if (*(kbd->leds) == kbd->newleds){ spin_unlock_irqrestore(&kbd->leds_lock, flags); return 0; } *(kbd->leds) = kbd->newleds; kbd->led->dev = kbd->usbdev; if (usb_submit_urb(kbd->led, GFP_ATOMIC)) pr_err("usb_submit_urb(leds) failed\n"); else kbd->led_urb_submitted = true; spin_unlock_irqrestore(&kbd->leds_lock, flags); return 0; } 2.c.5 Mã nguồn usb driver #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include #include #include #include #include #include /* * Version Information */ #define DRIVER_VERSION "" #define DRIVER_AUTHOR "Kma software developer" #define DRIVER_DESC "USB HID Boot Protocol keyboard driver" #define DRIVER_LICENSE "GPL" MODULE_AUTHOR(DRIVER_AUTHOR); MODULE_DESCRIPTION(DRIVER_DESC); MODULE_LICENSE(DRIVER_LICENSE); 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_kbd { struct input_dev *dev; struct usb_device *usbdev; unsigned char old[8]; struct urb *irq, *led; unsigned char newleds; char name[128]; char phys[64]; unsigned char *new; struct usb_ctrlrequest *cr; unsigned char *leds; dma_addr_t new_dma; dma_addr_t leds_dma; spinlock_t leds_lock; bool led_urb_submitted; bool mode; }; // mode == means mode 1, mode == means mode static void usb_kbd_irq(struct urb *urb) { struct usb_kbd *kbd = urb->context; int i; switch (urb->status) { case 0: /* success */ break; case -ECONNRESET: /* unlink */ case -ENOENT: case -ESHUTDOWN: return; /* -EPIPE: should clear the halt */ default: /* error */ goto resubmit; } for (i = 0; i < 8; i++) input_report_key(kbd->dev, usb_kbd_keycode[i + 224], (kbd->new[0] >> i) & 1); for (i = 2; i < 8; i++) { if (kbd->old[i] > && memscan(kbd->new + 2, kbd->old[i], 6) == kbd->new + 8) { if (usb_kbd_keycode[kbd->old[i]]) input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0); else hid_info(urb->dev, "Unknown key (scancode %#x) released.\n", kbd->old[i]); } if (kbd->new[i] > && memscan(kbd->old + 2, kbd->new[i], 6) == kbd->old + 8) { if (usb_kbd_keycode[kbd->new[i]]) input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1); else hid_info(urb->dev, "Unknown key (scancode %#x) pressed.\n", kbd->new[i]); } } input_sync(kbd->dev); memcpy(kbd->old, kbd->new, 8); resubmit: i = usb_submit_urb (urb, GFP_ATOMIC); if (i) hid_err(urb->dev, "can't resubmit intr, %s-%s/input0, status %d", kbd->usbdev->bus->bus_name, kbd->usbdev->devpath, i); } static int usb_kbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { unsigned long flags; struct usb_kbd *kbd = input_get_drvdata(dev); if (type != EV_LED) return -1; spin_lock_irqsave(&kbd->leds_lock, flags); // if (kbd->mode == 0) { if (((!!test_bit(LED_NUML, dev->led)) != (*(kbd->leds) & 1))&&((!! test_bit(LED_CAPSL, dev->led)) == 0)) { kbd->mode = 1; kbd->newleds = (!!test_bit(LED_KANA, dev->led) led) led) newleds = (!!test_bit(LED_KANA, dev->led) led) led) led) led)); } } else { if ((!!test_bit(LED_NUML, dev->led)) != (*(kbd->leds) & 1)) { kbd->mode = 0; kbd->newleds = (!!test_bit(LED_KANA, dev->led) led) led) led) led)); printk("Now change to MODE 1\n"); } else { kbd->newleds = (!!test_bit(LED_KANA, dev->led) led) led) led) led)); } } // if (kbd->led_urb_submitted){ spin_unlock_irqrestore(&kbd->leds_lock, flags); return 0; } if (*(kbd->leds) == kbd->newleds){ spin_unlock_irqrestore(&kbd->leds_lock, flags); return 0; } *(kbd->leds) = kbd->newleds; kbd->led->dev = kbd->usbdev; if (usb_submit_urb(kbd->led, GFP_ATOMIC)) pr_err("usb_submit_urb(leds) failed\n"); else kbd->led_urb_submitted = true; spin_unlock_irqrestore(&kbd->leds_lock, flags); return 0; } static void usb_kbd_led(struct urb *urb) { unsigned long flags; struct usb_kbd *kbd = urb->context; /*add print*/ printk(KERN_ALERT "Received a URB from CTRL endpoint.\n"); /*add print*/ if (urb->status) hid_warn(urb->dev, "led urb status %d received\n", urb->status); spin_lock_irqsave(&kbd->leds_lock, flags); if (*(kbd->leds) == kbd->newleds){ kbd->led_urb_submitted = false; spin_unlock_irqrestore(&kbd->leds_lock, flags); return; } *(kbd->leds) = kbd->newleds; kbd->led->dev = kbd->usbdev; if (usb_submit_urb(kbd->led, GFP_ATOMIC)){ hid_err(urb->dev, "usb_submit_urb(leds) failed\n"); kbd->led_urb_submitted = false; } spin_unlock_irqrestore(&kbd->leds_lock, flags); } static int usb_kbd_open(struct input_dev *dev) { struct usb_kbd *kbd = input_get_drvdata(dev); /*add print*/ printk(KERN_ALERT "Just open the USB keyboard device.\n"); /*add print*/ kbd->irq->dev = kbd->usbdev; if (usb_submit_urb(kbd->irq, GFP_KERNEL)) return -EIO; return 0; } static void usb_kbd_close(struct input_dev *dev) { struct usb_kbd *kbd = input_get_drvdata(dev); /*add print*/ printk(KERN_ALERT "Just close the USB keyboard device.\n"); /*add print*/ usb_kill_urb(kbd->irq); } static int usb_kbd_alloc_mem(struct usb_device *dev, struct usb_kbd *kbd) { if (!(kbd->irq = usb_alloc_urb(0, GFP_KERNEL))) return -1; if (!(kbd->led = usb_alloc_urb(0, GFP_KERNEL))) return -1; if (!(kbd->new = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &kbd->new_dma))) return -1; if (!(kbd->cr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL))) return -1; if (!(kbd->leds = usb_alloc_coherent(dev, 1, GFP_ATOMIC, &kbd->leds_dma))) return -1; return 0; } static void usb_kbd_free_mem(struct usb_device *dev, struct usb_kbd *kbd) { usb_free_urb(kbd->irq); usb_free_urb(kbd->led); usb_free_coherent(dev, 8, kbd->new, kbd->new_dma); kfree(kbd->cr); usb_free_coherent(dev, 1, kbd->leds, kbd->leds_dma); } static int usb_kbd_probe(struct usb_interface *iface, const struct usb_device_id *id) { struct usb_device *dev = interface_to_usbdev(iface); struct usb_host_interface *interface; struct usb_endpoint_descriptor *endpoint; struct usb_kbd *kbd; struct input_dev *input_dev; int i, pipe, maxp; int error = -ENOMEM; /*add print*/ printk(KERN_ALERT "usbkbd driver probing USB keyboard device \n"); /*add print*/ interface = iface->cur_altsetting; if (interface->desc.bNumEndpoints != 1) return -ENODEV; endpoint = &interface->endpoint[0].desc; if (!usb_endpoint_is_int_in(endpoint)) return -ENODEV; pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress); maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe)); kbd = kzalloc(sizeof(struct usb_kbd), GFP_KERNEL); input_dev = input_allocate_device(); if (!kbd || !input_dev) goto fail1; if (usb_kbd_alloc_mem(dev, kbd)) goto fail2; kbd->usbdev = dev; kbd->dev = input_dev; spin_lock_init(&kbd->leds_lock); if (dev->manufacturer) strlcpy(kbd->name, dev->manufacturer, sizeof(kbd->name)); if (dev->product) { if (dev->manufacturer) strlcat(kbd->name, " ", sizeof(kbd->name)); strlcat(kbd->name, dev->product, sizeof(kbd->name)); } if (!strlen(kbd->name)) snprintf(kbd->name, sizeof(kbd->name), "USB HIDBP Keyboard %04x:%04x", le16_to_cpu(dev->descriptor.idVendor), le16_to_cpu(dev->descriptor.idProduct)); usb_make_path(dev, kbd->phys, sizeof(kbd->phys)); strlcat(kbd->phys, "/input0", sizeof(kbd->phys)); input_dev->name = kbd->name; input_dev->phys = kbd->phys; usb_to_input_id(dev, &input_dev->id); input_dev->dev.parent = &iface->dev; input_set_drvdata(input_dev, kbd); input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_LED) | BIT_MASK(EV_REP); input_dev->ledbit[0] = BIT_MASK(LED_NUML) | BIT_MASK(LED_CAPSL) | BIT_MASK(LED_SCROLLL) | BIT_MASK(LED_COMPOSE) | BIT_MASK(LED_KANA); for (i = 0; i < 255; i++) set_bit(usb_kbd_keycode[i], input_dev->keybit); clear_bit(0, input_dev->keybit); input_dev->event = usb_kbd_event; input_dev->open = usb_kbd_open; input_dev->close = usb_kbd_close; usb_fill_int_urb(kbd->irq, dev, pipe, kbd->new, (maxp > ? : maxp), usb_kbd_irq, kbd, endpoint->bInterval); kbd->irq->transfer_dma = kbd->new_dma; kbd->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; kbd->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE; kbd->cr->bRequest = 0x09; kbd->cr->wValue = cpu_to_le16(0x200); kbd->cr->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber); kbd->cr->wLength = cpu_to_le16(1); usb_fill_control_urb(kbd->led, dev, usb_sndctrlpipe(dev, 0), (void *) kbd->cr, kbd->leds, 1, usb_kbd_led, kbd); kbd->led->transfer_dma = kbd->leds_dma; kbd->led->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; error = input_register_device(kbd->dev); if (error) goto fail2; usb_set_intfdata(iface, kbd); device_set_wakeup_enable(&dev->dev, 1); return 0; fail2: usb_kbd_free_mem(dev, kbd); fail1: input_free_device(input_dev); kfree(kbd); return error; } static void usb_kbd_disconnect(struct usb_interface *intf) { struct usb_kbd *kbd = usb_get_intfdata (intf); /*add print*/ printk(KERN_ALERT "Time to say bye to the USB keyboard device \n"); /*add print*/ usb_set_intfdata(intf, NULL); if (kbd) { usb_kill_urb(kbd->irq); input_unregister_device(kbd->dev); usb_kill_urb(kbd->led); usb_kbd_free_mem(interface_to_usbdev(intf), kbd); kfree(kbd); } } 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_kbd_driver = { name = "usbkbd", probe = usb_kbd_probe, disconnect = usb_kbd_disconnect, id_table = usb_kbd_id_table, }; module_usb_driver(usb_kbd_driver); KẾT LUẬN Kết đạt được: Xây dụng usb driver thay cho driver cũ hệ điều hành Hạn chế: Do thời gian xây dựng nhân phụ thuộc cấu hình máy, đồng thời chưa tối ưu hiệu so driver cũ hệ thống Hướng phát triển tiếp: Refactor (tối ưu) mã nguồn thuật toán driver TÀI LIỆU THAM KHẢO [1] Driver usb keyboard linux – Link tham khảo: https://www.programmersought.com/article/51464862211/ [2] Cài đặt GNU Make - eslinuxprogramming.blogspot.com/2015/04/gnumake.html [3] Cài đặt Ubuntu VMware - openplanning.net/11327/cai-dat-ubuntudesktop-trong-vmware [4] Mã nguồn driver: https://github.com/torvalds/linux/blob/master/drivers/hid/usbhid/usbkbd.c