git.sur5r.net Git - u-boot/blob - drivers/usb/emul/usb-emul-uclass.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 <usb.h>
  11 #include <dm/device-internal.h>
  12
  13 DECLARE_GLOBAL_DATA_PTR;
  14
  15 static int copy_to_unicode(char *buff, int length, const char *str)
  16 {
  17         int ptr;
  18         int i;
  19
  20         if (length < 2)
  21                 return 0;
  22         buff[1] = USB_DT_STRING;
  23         for (ptr = 2, i = 0; ptr + 1 < length && *str; i++, ptr += 2) {
  24                 buff[ptr] = str[i];
  25                 buff[ptr + 1] = 0;
  26         }
  27         buff[0] = ptr;
  28
  29         return ptr;
  30 }
  31
  32 static int usb_emul_get_string(struct usb_string *strings, int index,
  33                                char *buff, int length)
  34 {
  35         if (index == 0) {
  36                 char *desc = buff;
  37
  38                 desc[0] = 4;
  39                 desc[1] = USB_DT_STRING;
  40                 desc[2] = 0x09;
  41                 desc[3] = 0x14;
  42                 return 4;
  43         } else if (strings) {
  44                 struct usb_string *ptr;
  45
  46                 for (ptr = strings; ptr->s; ptr++) {
  47                         if (ptr->id == index)
  48                                 return copy_to_unicode(buff, length, ptr->s);
  49                 }
  50         }
  51
  52         return -EINVAL;
  53 }
  54
  55 static struct usb_generic_descriptor **find_descriptor(
  56                 struct usb_generic_descriptor **ptr, int type, int index)
  57 {
  58         debug("%s: type=%x, index=%d\n", __func__, type, index);
  59         for (; *ptr; ptr++) {
  60                 if ((*ptr)->bDescriptorType != type)
  61                         continue;
  62                 switch (type) {
  63                 case USB_DT_CONFIG: {
  64                         struct usb_config_descriptor *cdesc;
  65
  66                         cdesc = (struct usb_config_descriptor *)*ptr;
  67                         if (cdesc && cdesc->bConfigurationValue == index)
  68                                 return ptr;
  69                         break;
  70                 }
  71                 default:
  72                         return ptr;
  73                 }
  74         }
  75         debug("%s: config ptr=%p\n", __func__, *ptr);
  76
  77         return ptr;
  78 }
  79
  80 static int usb_emul_get_descriptor(struct usb_dev_platdata *plat, int value,
  81                                    void *buffer, int length)
  82 {
  83         struct usb_generic_descriptor **ptr;
  84         int type = value >> 8;
  85         int index = value & 0xff;
  86         int upto, todo;
  87
  88         debug("%s: type=%d, index=%d, plat=%p\n", __func__, type, index, plat);
  89         if (type == USB_DT_STRING) {
  90                 return usb_emul_get_string(plat->strings, index, buffer,
  91                                            length);
  92         }
  93
  94         ptr = find_descriptor((struct usb_generic_descriptor **)plat->desc_list,
  95                               type, index);
  96         if (!ptr) {
  97                 debug("%s: Could not find descriptor type %d, index %d\n",
  98                       __func__, type, index);
  99                 return -ENOENT;
 100         }
 101         for (upto = 0; *ptr && upto < length; ptr++, upto += todo) {
 102                 todo = min(length - upto, (int)(*ptr)->bLength);
 103
 104                 memcpy(buffer + upto, *ptr, todo);
 105         }
 106
 107         return upto ? upto : length ? -EIO : 0;
 108 }
 109
 110 static int usb_emul_find_devnum(int devnum, struct udevice **emulp)
 111 {
 112         struct udevice *dev;
 113         struct uclass *uc;
 114         int ret;
 115
 116         *emulp = NULL;
 117         ret = uclass_get(UCLASS_USB_EMUL, &uc);
 118         if (ret)
 119                 return ret;
 120         uclass_foreach_dev(dev, uc) {
 121                 struct usb_dev_platdata *udev = dev_get_parent_platdata(dev);
 122
 123                 if (udev->devnum == devnum) {
 124                         debug("%s: Found emulator '%s', addr %d\n", __func__,
 125                               dev->name, udev->devnum);
 126                         *emulp = dev;
 127                         return 0;
 128                 }
 129         }
 130
 131         debug("%s: No emulator found, addr %d\n", __func__, devnum);
 132         return -ENOENT;
 133 }
 134
 135 int usb_emul_find(struct udevice *bus, ulong pipe, struct udevice **emulp)
 136 {
 137         int devnum = usb_pipedevice(pipe);
 138
 139         return usb_emul_find_devnum(devnum, emulp);
 140 }
 141
 142 int usb_emul_find_for_dev(struct udevice *dev, struct udevice **emulp)
 143 {
 144         struct usb_dev_platdata *udev = dev_get_parent_platdata(dev);
 145
 146         return usb_emul_find_devnum(udev->devnum, emulp);
 147 }
 148
 149 int usb_emul_control(struct udevice *emul, struct usb_device *udev,
 150                      unsigned long pipe, void *buffer, int length,
 151                      struct devrequest *setup)
 152 {
 153         struct dm_usb_ops *ops = usb_get_emul_ops(emul);
 154         struct usb_dev_platdata *plat;
 155         int ret;
 156
 157         /* We permit getting the descriptor before we are probed */
 158         plat = dev_get_parent_platdata(emul);
 159         if (!ops->control)
 160                 return -ENOSYS;
 161         debug("%s: dev=%s\n", __func__, emul->name);
 162         if (pipe == usb_rcvctrlpipe(udev, 0)) {
 163                 switch (setup->request) {
 164                 case USB_REQ_GET_DESCRIPTOR: {
 165                         return usb_emul_get_descriptor(plat, setup->value,
 166                                                        buffer, length);
 167                 }
 168                 default:
 169                         ret = device_probe(emul);
 170                         if (ret)
 171                                 return ret;
 172                         return ops->control(emul, udev, pipe, buffer, length,
 173                                             setup);
 174                 }
 175         } else if (pipe == usb_snddefctrl(udev)) {
 176                 switch (setup->request) {
 177                 case USB_REQ_SET_ADDRESS:
 178                         debug("   ** set address %s %d\n", emul->name,
 179                               setup->value);
 180                         plat->devnum = setup->value;
 181                         return 0;
 182                 default:
 183                         debug("requestsend =%x\n", setup->request);
 184                         break;
 185                 }
 186         } else if (pipe == usb_sndctrlpipe(udev, 0)) {
 187                 switch (setup->request) {
 188                 case USB_REQ_SET_CONFIGURATION:
 189                         plat->configno = setup->value;
 190                         return 0;
 191                 default:
 192                         ret = device_probe(emul);
 193                         if (ret)
 194                                 return ret;
 195                         return ops->control(emul, udev, pipe, buffer, length,
 196                                             setup);
 197                 }
 198         }
 199         debug("pipe=%lx\n", pipe);
 200
 201         return -EIO;
 202 }
 203
 204 int usb_emul_bulk(struct udevice *emul, struct usb_device *udev,
 205                   unsigned long pipe, void *buffer, int length)
 206 {
 207         struct dm_usb_ops *ops = usb_get_emul_ops(emul);
 208         int ret;
 209
 210         /* We permit getting the descriptor before we are probed */
 211         if (!ops->bulk)
 212                 return -ENOSYS;
 213         debug("%s: dev=%s\n", __func__, emul->name);
 214         ret = device_probe(emul);
 215         if (ret)
 216                 return ret;
 217         return ops->bulk(emul, udev, pipe, buffer, length);
 218 }
 219
 220 int usb_emul_int(struct udevice *emul, struct usb_device *udev,
 221                   unsigned long pipe, void *buffer, int length, int interval)
 222 {
 223         struct dm_usb_ops *ops = usb_get_emul_ops(emul);
 224
 225         if (!ops->interrupt)
 226                 return -ENOSYS;
 227         debug("%s: dev=%s\n", __func__, emul->name);
 228
 229         return ops->interrupt(emul, udev, pipe, buffer, length, interval);
 230 }
 231
 232 int usb_emul_setup_device(struct udevice *dev, int maxpacketsize,
 233                           struct usb_string *strings, void **desc_list)
 234 {
 235         struct usb_dev_platdata *plat = dev_get_parent_platdata(dev);
 236         struct usb_generic_descriptor **ptr;
 237         struct usb_config_descriptor *cdesc;
 238         int upto;
 239
 240         plat->strings = strings;
 241         plat->desc_list = (struct usb_generic_descriptor **)desc_list;
 242
 243         /* Fill in wTotalLength for each configuration descriptor */
 244         ptr = plat->desc_list;
 245         for (cdesc = NULL, upto = 0; *ptr; upto += (*ptr)->bLength, ptr++) {
 246                 debug("   - upto=%d, type=%d\n", upto, (*ptr)->bDescriptorType);
 247                 if ((*ptr)->bDescriptorType == USB_DT_CONFIG) {
 248                         if (cdesc) {
 249                                 cdesc->wTotalLength = upto;
 250                                 debug("%s: config %d length %d\n", __func__,
 251                                       cdesc->bConfigurationValue,
 252                                       cdesc->bLength);
 253                         }
 254                         cdesc = (struct usb_config_descriptor *)*ptr;
 255                         upto = 0;
 256                 }
 257         }
 258         if (cdesc) {
 259                 cdesc->wTotalLength = upto;
 260                 debug("%s: config %d length %d\n", __func__,
 261                       cdesc->bConfigurationValue, cdesc->wTotalLength);
 262         }
 263
 264         return 0;
 265 }
 266
 267 int usb_emul_post_bind(struct udevice *dev)
 268 {
 269         /* Scan the bus for devices */
 270         return dm_scan_fdt_dev(dev);
 271 }
 272
 273 void usb_emul_reset(struct udevice *dev)
 274 {
 275         struct usb_dev_platdata *plat = dev_get_parent_platdata(dev);
 276
 277         plat->devnum = 0;
 278         plat->configno = 0;
 279 }
 280
 281 UCLASS_DRIVER(usb_emul) = {
 282         .id             = UCLASS_USB_EMUL,
 283         .name           = "usb_emul",
 284         .post_bind      = usb_emul_post_bind,
 285         .per_child_auto_alloc_size = sizeof(struct usb_device),
 286         .per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata),
 287 };