drivers/usb/emul/sandbox_keyb.c

   1 /*
   2  * (C) Copyright 2015 Google, Inc
   3  * Written by Simon Glass <sjg@chromium.org>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <dm.h>
  10 #include <os.h>
  11 #include <scsi.h>
  12 #include <usb.h>
  13
  14 DECLARE_GLOBAL_DATA_PTR;
  15
  16 /*
  17  * This driver emulates a USB keyboard using the USB HID specification (boot
  18  * protocol)
  19  */
  20
  21 enum {
  22         SANDBOX_KEYB_EP_IN              = 1,    /* endpoints */
  23 };
  24
  25 enum cmd_phase {
  26         PHASE_START,
  27         PHASE_DATA,
  28         PHASE_STATUS,
  29 };
  30
  31 enum {
  32         STRINGID_MANUFACTURER = 1,
  33         STRINGID_PRODUCT,
  34         STRINGID_SERIAL,
  35
  36         STRINGID_COUNT,
  37 };
  38
  39 /**
  40  * struct sandbox_keyb_priv - private state for this driver
  41  *
  42  */
  43 struct sandbox_keyb_priv {
  44         struct membuff in;
  45 };
  46
  47 struct sandbox_keyb_plat {
  48         struct usb_string keyb_strings[STRINGID_COUNT];
  49 };
  50
  51 static struct usb_device_descriptor keyb_device_desc = {
  52         .bLength =              sizeof(keyb_device_desc),
  53         .bDescriptorType =      USB_DT_DEVICE,
  54
  55         .bcdUSB =               __constant_cpu_to_le16(0x0100),
  56
  57         .bDeviceClass =         0,
  58         .bDeviceSubClass =      0,
  59         .bDeviceProtocol =      0,
  60
  61         .idVendor =             __constant_cpu_to_le16(0x1234),
  62         .idProduct =            __constant_cpu_to_le16(0x5679),
  63         .iManufacturer =        STRINGID_MANUFACTURER,
  64         .iProduct =             STRINGID_PRODUCT,
  65         .iSerialNumber =        STRINGID_SERIAL,
  66         .bNumConfigurations =   1,
  67 };
  68
  69 static struct usb_config_descriptor keyb_config0 = {
  70         .bLength                = sizeof(keyb_config0),
  71         .bDescriptorType        = USB_DT_CONFIG,
  72
  73         /* wTotalLength is set up by usb-emul-uclass */
  74         .bNumInterfaces         = 2,
  75         .bConfigurationValue    = 0,
  76         .iConfiguration         = 0,
  77         .bmAttributes           = 1 << 7 | 1 << 5,
  78         .bMaxPower              = 50,
  79 };
  80
  81 static struct usb_interface_descriptor keyb_interface0 = {
  82         .bLength                = sizeof(keyb_interface0),
  83         .bDescriptorType        = USB_DT_INTERFACE,
  84
  85         .bInterfaceNumber       = 0,
  86         .bAlternateSetting      = 0,
  87         .bNumEndpoints          = 1,
  88         .bInterfaceClass        = USB_CLASS_HID,
  89         .bInterfaceSubClass     = USB_SUB_HID_BOOT,
  90         .bInterfaceProtocol     = USB_PROT_HID_KEYBOARD,
  91         .iInterface             = 0,
  92 };
  93
  94 static struct usb_class_hid_descriptor keyb_report0 = {
  95         .bLength                = sizeof(keyb_report0),
  96         .bDescriptorType        = USB_DT_HID,
  97         .bcdCDC                 = 0x101,
  98         .bCountryCode           = 0,
  99         .bNumDescriptors        = 1,
 100         .bDescriptorType0       = USB_DT_HID_REPORT,
 101         .wDescriptorLength0     = 0x3f,
 102 };
 103
 104 static struct usb_endpoint_descriptor keyb_endpoint0_in = {
 105         .bLength                = USB_DT_ENDPOINT_SIZE,
 106         .bDescriptorType        = USB_DT_ENDPOINT,
 107
 108         .bEndpointAddress       = SANDBOX_KEYB_EP_IN | USB_ENDPOINT_DIR_MASK,
 109         .bmAttributes           = USB_ENDPOINT_XFER_BULK |
 110                                         USB_ENDPOINT_XFER_ISOC,
 111         .wMaxPacketSize         = __constant_cpu_to_le16(8),
 112         .bInterval              = 0xa,
 113 };
 114
 115 static struct usb_interface_descriptor keyb_interface1 = {
 116         .bLength                = sizeof(keyb_interface1),
 117         .bDescriptorType        = USB_DT_INTERFACE,
 118
 119         .bInterfaceNumber       = 1,
 120         .bAlternateSetting      = 0,
 121         .bNumEndpoints          = 1,
 122         .bInterfaceClass        = USB_CLASS_HID,
 123         .bInterfaceSubClass     = USB_SUB_HID_BOOT,
 124         .bInterfaceProtocol     = USB_PROT_HID_MOUSE,
 125         .iInterface             = 0,
 126 };
 127
 128 static struct usb_class_hid_descriptor keyb_report1 = {
 129         .bLength                = sizeof(struct usb_class_hid_descriptor),
 130         .bDescriptorType        = USB_DT_HID,
 131         .bcdCDC                 = 0x101,
 132         .bCountryCode           = 0,
 133         .bNumDescriptors        = 1,
 134         .bDescriptorType0       = USB_DT_HID_REPORT,
 135         .wDescriptorLength0     = 0x32,
 136 };
 137
 138 static struct usb_endpoint_descriptor keyb_endpoint1_in = {
 139         .bLength                = USB_DT_ENDPOINT_SIZE,
 140         .bDescriptorType        = USB_DT_ENDPOINT,
 141
 142         .bEndpointAddress       = SANDBOX_KEYB_EP_IN | USB_ENDPOINT_DIR_MASK,
 143         .bmAttributes           = USB_ENDPOINT_XFER_BULK |
 144                                         USB_ENDPOINT_XFER_ISOC,
 145         .wMaxPacketSize         = __constant_cpu_to_le16(8),
 146         .bInterval              = 0xa,
 147 };
 148
 149 static void *keyb_desc_list[] = {
 150         &keyb_device_desc,
 151         &keyb_config0,
 152         &keyb_interface0,
 153         &keyb_report0,
 154         &keyb_endpoint0_in,
 155         &keyb_interface1,
 156         &keyb_report1,
 157         &keyb_endpoint1_in,
 158         NULL,
 159 };
 160
 161 int sandbox_usb_keyb_add_string(struct udevice *dev, const char *str)
 162 {
 163         struct sandbox_keyb_priv *priv = dev_get_priv(dev);
 164         int len, ret;
 165
 166         len = strlen(str);
 167         ret = membuff_put(&priv->in, str, len);
 168         if (ret != len)
 169                 return -ENOSPC;
 170
 171         return 0;
 172 }
 173
 174 static int sandbox_keyb_control(struct udevice *dev, struct usb_device *udev,
 175                                 unsigned long pipe, void *buff, int len,
 176                                 struct devrequest *setup)
 177 {
 178         debug("pipe=%lx\n", pipe);
 179
 180         return -EIO;
 181 }
 182
 183 static int sandbox_keyb_interrupt(struct udevice *dev, struct usb_device *udev,
 184                 unsigned long pipe, void *buffer, int length, int interval)
 185 {
 186         struct sandbox_keyb_priv *priv = dev_get_priv(dev);
 187         uint8_t *data = buffer;
 188         int ch;
 189
 190         memset(data, '\0', length);
 191         ch = membuff_getbyte(&priv->in);
 192         if (ch != -1)
 193                 data[2] = 4 + ch - 'a';
 194
 195         return 0;
 196 }
 197
 198 static int sandbox_keyb_bind(struct udevice *dev)
 199 {
 200         struct sandbox_keyb_plat *plat = dev_get_platdata(dev);
 201         struct usb_string *fs;
 202
 203         fs = plat->keyb_strings;
 204         fs[0].id = STRINGID_MANUFACTURER;
 205         fs[0].s = "sandbox";
 206         fs[1].id = STRINGID_PRODUCT;
 207         fs[1].s = "keyboard";
 208         fs[2].id = STRINGID_SERIAL;
 209         fs[2].s = dev->name;
 210
 211         return usb_emul_setup_device(dev, PACKET_SIZE_8, plat->keyb_strings,
 212                                      keyb_desc_list);
 213 }
 214
 215 static int sandbox_keyb_probe(struct udevice *dev)
 216 {
 217         struct sandbox_keyb_priv *priv = dev_get_priv(dev);
 218
 219         return membuff_new(&priv->in, 256);
 220 }
 221
 222 static const struct dm_usb_ops sandbox_usb_keyb_ops = {
 223         .control        = sandbox_keyb_control,
 224         .interrupt      = sandbox_keyb_interrupt,
 225 };
 226
 227 static const struct udevice_id sandbox_usb_keyb_ids[] = {
 228         { .compatible = "sandbox,usb-keyb" },
 229         { }
 230 };
 231
 232 U_BOOT_DRIVER(usb_sandbox_keyb) = {
 233         .name   = "usb_sandbox_keyb",
 234         .id     = UCLASS_USB_EMUL,
 235         .of_match = sandbox_usb_keyb_ids,
 236         .bind   = sandbox_keyb_bind,
 237         .probe  = sandbox_keyb_probe,
 238         .ops    = &sandbox_usb_keyb_ops,
 239         .priv_auto_alloc_size = sizeof(struct sandbox_keyb_priv),
 240         .platdata_auto_alloc_size = sizeof(struct sandbox_keyb_plat),
 241 };