hid/usbhid/usbkbd.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Copyright (c) 1999-2001 Vojtech Pavlik
0004  *
0005  *  USB HIDBP Keyboard support
0006  */
0007
0008 /*
0009  *
0010  * Should you need to contact me, the author, you can do so either by
0011  * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
0012  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
0013  */
0014
0015 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0016
0017 #include <linux/kernel.h>
0018 #include <linux/slab.h>
0019 #include <linux/module.h>
0020 #include <linux/init.h>
0021 #include <linux/usb/input.h>
0022 #include <linux/hid.h>
0023
0024 /*
0025  * Version Information
0026  */
0027 #define DRIVER_VERSION ""
0028 #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
0029 #define DRIVER_DESC "USB HID Boot Protocol keyboard driver"
0030
0031 MODULE_AUTHOR(DRIVER_AUTHOR);
0032 MODULE_DESCRIPTION(DRIVER_DESC);
0033 MODULE_LICENSE("GPL");
0034
0035 static const unsigned char usb_kbd_keycode[256] = {
0036       0,  0,  0,  0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
0037      50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44,  2,  3,
0038       4,  5,  6,  7,  8,  9, 10, 11, 28,  1, 14, 15, 57, 12, 13, 26,
0039      27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
0040      65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
0041     105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
0042      72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
0043     191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
0044     115,114,  0,  0,  0,121,  0, 89, 93,124, 92, 94, 95,  0,  0,  0,
0045     122,123, 90, 91, 85,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0046       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0047       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0048       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0049       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0050      29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
0051     150,158,159,128,136,177,178,176,142,152,173,140
0052 };
0053
0054
0055 /**
0056  * struct usb_kbd - state of each attached keyboard
0057  * @dev:    input device associated with this keyboard
0058  * @usbdev: usb device associated with this keyboard
0059  * @old:    data received in the past from the @irq URB representing which
0060  *      keys were pressed. By comparing with the current list of keys
0061  *      that are pressed, we are able to see key releases.
0062  * @irq:    URB for receiving a list of keys that are pressed when a
0063  *      new key is pressed or a key that was pressed is released.
0064  * @led:    URB for sending LEDs (e.g. numlock, ...)
0065  * @newleds:    data that will be sent with the @led URB representing which LEDs
0066  *      should be on
0067  * @name:   Name of the keyboard. @dev's name field points to this buffer
0068  * @phys:   Physical path of the keyboard. @dev's phys field points to this
0069  *      buffer
0070  * @new:    Buffer for the @irq URB
0071  * @cr:     Control request for @led URB
0072  * @leds:   Buffer for the @led URB
0073  * @new_dma:    DMA address for @irq URB
0074  * @leds_dma:   DMA address for @led URB
0075  * @leds_lock:  spinlock that protects @leds, @newleds, and @led_urb_submitted
0076  * @led_urb_submitted: indicates whether @led is in progress, i.e. it has been
0077  *      submitted and its completion handler has not returned yet
0078  *      without resubmitting @led
0079  */
0080 struct usb_kbd {
0081     struct input_dev *dev;
0082     struct usb_device *usbdev;
0083     unsigned char old[8];
0084     struct urb *irq, *led;
0085     unsigned char newleds;
0086     char name[128];
0087     char phys[64];
0088
0089     unsigned char *new;
0090     struct usb_ctrlrequest *cr;
0091     unsigned char *leds;
0092     dma_addr_t new_dma;
0093     dma_addr_t leds_dma;
0094
0095     spinlock_t leds_lock;
0096     bool led_urb_submitted;
0097
0098 };
0099
0100 static void usb_kbd_irq(struct urb *urb)
0101 {
0102     struct usb_kbd *kbd = urb->context;
0103     int i;
0104
0105     switch (urb->status) {
0106     case 0:         /* success */
0107         break;
0108     case -ECONNRESET:   /* unlink */
0109     case -ENOENT:
0110     case -ESHUTDOWN:
0111         return;
0112     /* -EPIPE:  should clear the halt */
0113     default:        /* error */
0114         goto resubmit;
0115     }
0116
0117     for (i = 0; i < 8; i++)
0118         input_report_key(kbd->dev, usb_kbd_keycode[i + 224], (kbd->new[0] >> i) & 1);
0119
0120     for (i = 2; i < 8; i++) {
0121
0122         if (kbd->old[i] > 3 && memscan(kbd->new + 2, kbd->old[i], 6) == kbd->new + 8) {
0123             if (usb_kbd_keycode[kbd->old[i]])
0124                 input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0);
0125             else
0126                 hid_info(urb->dev,
0127                      "Unknown key (scancode %#x) released.\n",
0128                      kbd->old[i]);
0129         }
0130
0131         if (kbd->new[i] > 3 && memscan(kbd->old + 2, kbd->new[i], 6) == kbd->old + 8) {
0132             if (usb_kbd_keycode[kbd->new[i]])
0133                 input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1);
0134             else
0135                 hid_info(urb->dev,
0136                      "Unknown key (scancode %#x) pressed.\n",
0137                      kbd->new[i]);
0138         }
0139     }
0140
0141     input_sync(kbd->dev);
0142
0143     memcpy(kbd->old, kbd->new, 8);
0144
0145 resubmit:
0146     i = usb_submit_urb (urb, GFP_ATOMIC);
0147     if (i)
0148         hid_err(urb->dev, "can't resubmit intr, %s-%s/input0, status %d",
0149             kbd->usbdev->bus->bus_name,
0150             kbd->usbdev->devpath, i);
0151 }
0152
0153 static int usb_kbd_event(struct input_dev *dev, unsigned int type,
0154              unsigned int code, int value)
0155 {
0156     unsigned long flags;
0157     struct usb_kbd *kbd = input_get_drvdata(dev);
0158
0159     if (type != EV_LED)
0160         return -1;
0161
0162     spin_lock_irqsave(&kbd->leds_lock, flags);
0163     kbd->newleds = (!!test_bit(LED_KANA,    dev->led) << 3) | (!!test_bit(LED_COMPOSE, dev->led) << 3) |
0164                (!!test_bit(LED_SCROLLL, dev->led) << 2) | (!!test_bit(LED_CAPSL,   dev->led) << 1) |
0165                (!!test_bit(LED_NUML,    dev->led));
0166
0167     if (kbd->led_urb_submitted){
0168         spin_unlock_irqrestore(&kbd->leds_lock, flags);
0169         return 0;
0170     }
0171
0172     if (*(kbd->leds) == kbd->newleds){
0173         spin_unlock_irqrestore(&kbd->leds_lock, flags);
0174         return 0;
0175     }
0176
0177     *(kbd->leds) = kbd->newleds;
0178
0179     kbd->led->dev = kbd->usbdev;
0180     if (usb_submit_urb(kbd->led, GFP_ATOMIC))
0181         pr_err("usb_submit_urb(leds) failed\n");
0182     else
0183         kbd->led_urb_submitted = true;
0184
0185     spin_unlock_irqrestore(&kbd->leds_lock, flags);
0186
0187     return 0;
0188 }
0189
0190 static void usb_kbd_led(struct urb *urb)
0191 {
0192     unsigned long flags;
0193     struct usb_kbd *kbd = urb->context;
0194
0195     if (urb->status)
0196         hid_warn(urb->dev, "led urb status %d received\n",
0197              urb->status);
0198
0199     spin_lock_irqsave(&kbd->leds_lock, flags);
0200
0201     if (*(kbd->leds) == kbd->newleds){
0202         kbd->led_urb_submitted = false;
0203         spin_unlock_irqrestore(&kbd->leds_lock, flags);
0204         return;
0205     }
0206
0207     *(kbd->leds) = kbd->newleds;
0208
0209     kbd->led->dev = kbd->usbdev;
0210     if (usb_submit_urb(kbd->led, GFP_ATOMIC)){
0211         hid_err(urb->dev, "usb_submit_urb(leds) failed\n");
0212         kbd->led_urb_submitted = false;
0213     }
0214     spin_unlock_irqrestore(&kbd->leds_lock, flags);
0215
0216 }
0217
0218 static int usb_kbd_open(struct input_dev *dev)
0219 {
0220     struct usb_kbd *kbd = input_get_drvdata(dev);
0221
0222     kbd->irq->dev = kbd->usbdev;
0223     if (usb_submit_urb(kbd->irq, GFP_KERNEL))
0224         return -EIO;
0225
0226     return 0;
0227 }
0228
0229 static void usb_kbd_close(struct input_dev *dev)
0230 {
0231     struct usb_kbd *kbd = input_get_drvdata(dev);
0232
0233     usb_kill_urb(kbd->irq);
0234 }
0235
0236 static int usb_kbd_alloc_mem(struct usb_device *dev, struct usb_kbd *kbd)
0237 {
0238     if (!(kbd->irq = usb_alloc_urb(0, GFP_KERNEL)))
0239         return -1;
0240     if (!(kbd->led = usb_alloc_urb(0, GFP_KERNEL)))
0241         return -1;
0242     if (!(kbd->new = usb_alloc_coherent(dev, 8, GFP_KERNEL, &kbd->new_dma)))
0243         return -1;
0244     if (!(kbd->cr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL)))
0245         return -1;
0246     if (!(kbd->leds = usb_alloc_coherent(dev, 1, GFP_KERNEL, &kbd->leds_dma)))
0247         return -1;
0248
0249     return 0;
0250 }
0251
0252 static void usb_kbd_free_mem(struct usb_device *dev, struct usb_kbd *kbd)
0253 {
0254     usb_free_urb(kbd->irq);
0255     usb_free_urb(kbd->led);
0256     usb_free_coherent(dev, 8, kbd->new, kbd->new_dma);
0257     kfree(kbd->cr);
0258     usb_free_coherent(dev, 1, kbd->leds, kbd->leds_dma);
0259 }
0260
0261 static int usb_kbd_probe(struct usb_interface *iface,
0262              const struct usb_device_id *id)
0263 {
0264     struct usb_device *dev = interface_to_usbdev(iface);
0265     struct usb_host_interface *interface;
0266     struct usb_endpoint_descriptor *endpoint;
0267     struct usb_kbd *kbd;
0268     struct input_dev *input_dev;
0269     int i, pipe, maxp;
0270     int error = -ENOMEM;
0271
0272     interface = iface->cur_altsetting;
0273
0274     if (interface->desc.bNumEndpoints != 1)
0275         return -ENODEV;
0276
0277     endpoint = &interface->endpoint[0].desc;
0278     if (!usb_endpoint_is_int_in(endpoint))
0279         return -ENODEV;
0280
0281     pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
0282     maxp = usb_maxpacket(dev, pipe);
0283
0284     kbd = kzalloc(sizeof(struct usb_kbd), GFP_KERNEL);
0285     input_dev = input_allocate_device();
0286     if (!kbd || !input_dev)
0287         goto fail1;
0288
0289     if (usb_kbd_alloc_mem(dev, kbd))
0290         goto fail2;
0291
0292     kbd->usbdev = dev;
0293     kbd->dev = input_dev;
0294     spin_lock_init(&kbd->leds_lock);
0295
0296     if (dev->manufacturer)
0297         strlcpy(kbd->name, dev->manufacturer, sizeof(kbd->name));
0298
0299     if (dev->product) {
0300         if (dev->manufacturer)
0301             strlcat(kbd->name, " ", sizeof(kbd->name));
0302         strlcat(kbd->name, dev->product, sizeof(kbd->name));
0303     }
0304
0305     if (!strlen(kbd->name))
0306         snprintf(kbd->name, sizeof(kbd->name),
0307              "USB HIDBP Keyboard %04x:%04x",
0308              le16_to_cpu(dev->descriptor.idVendor),
0309              le16_to_cpu(dev->descriptor.idProduct));
0310
0311     usb_make_path(dev, kbd->phys, sizeof(kbd->phys));
0312     strlcat(kbd->phys, "/input0", sizeof(kbd->phys));
0313
0314     input_dev->name = kbd->name;
0315     input_dev->phys = kbd->phys;
0316     usb_to_input_id(dev, &input_dev->id);
0317     input_dev->dev.parent = &iface->dev;
0318
0319     input_set_drvdata(input_dev, kbd);
0320
0321     input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_LED) |
0322         BIT_MASK(EV_REP);
0323     input_dev->ledbit[0] = BIT_MASK(LED_NUML) | BIT_MASK(LED_CAPSL) |
0324         BIT_MASK(LED_SCROLLL) | BIT_MASK(LED_COMPOSE) |
0325         BIT_MASK(LED_KANA);
0326
0327     for (i = 0; i < 255; i++)
0328         set_bit(usb_kbd_keycode[i], input_dev->keybit);
0329     clear_bit(0, input_dev->keybit);
0330
0331     input_dev->event = usb_kbd_event;
0332     input_dev->open = usb_kbd_open;
0333     input_dev->close = usb_kbd_close;
0334
0335     usb_fill_int_urb(kbd->irq, dev, pipe,
0336              kbd->new, (maxp > 8 ? 8 : maxp),
0337              usb_kbd_irq, kbd, endpoint->bInterval);
0338     kbd->irq->transfer_dma = kbd->new_dma;
0339     kbd->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
0340
0341     kbd->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
0342     kbd->cr->bRequest = 0x09;
0343     kbd->cr->wValue = cpu_to_le16(0x200);
0344     kbd->cr->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);
0345     kbd->cr->wLength = cpu_to_le16(1);
0346
0347     usb_fill_control_urb(kbd->led, dev, usb_sndctrlpipe(dev, 0),
0348                  (void *) kbd->cr, kbd->leds, 1,
0349                  usb_kbd_led, kbd);
0350     kbd->led->transfer_dma = kbd->leds_dma;
0351     kbd->led->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
0352
0353     error = input_register_device(kbd->dev);
0354     if (error)
0355         goto fail2;
0356
0357     usb_set_intfdata(iface, kbd);
0358     device_set_wakeup_enable(&dev->dev, 1);
0359     return 0;
0360
0361 fail2:
0362     usb_kbd_free_mem(dev, kbd);
0363 fail1:
0364     input_free_device(input_dev);
0365     kfree(kbd);
0366     return error;
0367 }
0368
0369 static void usb_kbd_disconnect(struct usb_interface *intf)
0370 {
0371     struct usb_kbd *kbd = usb_get_intfdata (intf);
0372
0373     usb_set_intfdata(intf, NULL);
0374     if (kbd) {
0375         usb_kill_urb(kbd->irq);
0376         input_unregister_device(kbd->dev);
0377         usb_kill_urb(kbd->led);
0378         usb_kbd_free_mem(interface_to_usbdev(intf), kbd);
0379         kfree(kbd);
0380     }
0381 }
0382
0383 static const struct usb_device_id usb_kbd_id_table[] = {
0384     { USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
0385         USB_INTERFACE_PROTOCOL_KEYBOARD) },
0386     { }                     /* Terminating entry */
0387 };
0388
0389 MODULE_DEVICE_TABLE (usb, usb_kbd_id_table);
0390
0391 static struct usb_driver usb_kbd_driver = {
0392     .name =     "usbkbd",
0393     .probe =    usb_kbd_probe,
0394     .disconnect =   usb_kbd_disconnect,
0395     .id_table = usb_kbd_id_table,
0396 };
0397
0398 module_usb_driver(usb_kbd_driver);