git.sur5r.net Git - u-boot/blob - drivers/usb/host/usb-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 <errno.h>
  11 #include <usb.h>
  12 #include <dm/device-internal.h>
  13 #include <dm/lists.h>
  14 #include <dm/root.h>
  15 #include <dm/uclass-internal.h>
  16
  17 DECLARE_GLOBAL_DATA_PTR;
  18
  19 extern bool usb_started; /* flag for the started/stopped USB status */
  20 static bool asynch_allowed;
  21
  22 int usb_disable_asynch(int disable)
  23 {
  24         int old_value = asynch_allowed;
  25
  26         asynch_allowed = !disable;
  27         return old_value;
  28 }
  29
  30 int submit_int_msg(struct usb_device *udev, unsigned long pipe, void *buffer,
  31                    int length, int interval)
  32 {
  33         struct udevice *bus = udev->controller_dev;
  34         struct dm_usb_ops *ops = usb_get_ops(bus);
  35
  36         if (!ops->interrupt)
  37                 return -ENOSYS;
  38
  39         return ops->interrupt(bus, udev, pipe, buffer, length, interval);
  40 }
  41
  42 int submit_control_msg(struct usb_device *udev, unsigned long pipe,
  43                        void *buffer, int length, struct devrequest *setup)
  44 {
  45         struct udevice *bus = udev->controller_dev;
  46         struct dm_usb_ops *ops = usb_get_ops(bus);
  47
  48         if (!ops->control)
  49                 return -ENOSYS;
  50
  51         return ops->control(bus, udev, pipe, buffer, length, setup);
  52 }
  53
  54 int submit_bulk_msg(struct usb_device *udev, unsigned long pipe, void *buffer,
  55                     int length)
  56 {
  57         struct udevice *bus = udev->controller_dev;
  58         struct dm_usb_ops *ops = usb_get_ops(bus);
  59
  60         if (!ops->bulk)
  61                 return -ENOSYS;
  62
  63         return ops->bulk(bus, udev, pipe, buffer, length);
  64 }
  65
  66 int usb_alloc_device(struct usb_device *udev)
  67 {
  68         struct udevice *bus = udev->controller_dev;
  69         struct dm_usb_ops *ops = usb_get_ops(bus);
  70
  71         /* This is only requird by some controllers - current XHCI */
  72         if (!ops->alloc_device)
  73                 return 0;
  74
  75         return ops->alloc_device(bus, udev);
  76 }
  77
  78 int usb_stop(void)
  79 {
  80         struct udevice *bus;
  81         struct uclass *uc;
  82         int err = 0, ret;
  83
  84         /* De-activate any devices that have been activated */
  85         ret = uclass_get(UCLASS_USB, &uc);
  86         if (ret)
  87                 return ret;
  88         uclass_foreach_dev(bus, uc) {
  89                 ret = device_remove(bus);
  90                 if (ret && !err)
  91                         err = ret;
  92         }
  93
  94         usb_stor_reset();
  95         usb_hub_reset();
  96         usb_started = 0;
  97
  98         return err;
  99 }
 100
 101 static int usb_scan_bus(struct udevice *bus, bool recurse)
 102 {
 103         struct usb_bus_priv *priv;
 104         struct udevice *dev;
 105         int ret;
 106
 107         priv = dev_get_uclass_priv(bus);
 108
 109         assert(recurse);        /* TODO: Support non-recusive */
 110
 111         ret = usb_scan_device(bus, 0, USB_SPEED_FULL, &dev);
 112         if (ret)
 113                 return ret;
 114
 115         return priv->next_addr;
 116 }
 117
 118 int usb_init(void)
 119 {
 120         int controllers_initialized = 0;
 121         struct udevice *bus;
 122         struct uclass *uc;
 123         int count = 0;
 124         int ret;
 125
 126         asynch_allowed = 1;
 127         usb_hub_reset();
 128
 129         ret = uclass_get(UCLASS_USB, &uc);
 130         if (ret)
 131                 return ret;
 132
 133         uclass_foreach_dev(bus, uc) {
 134                 /* init low_level USB */
 135                 count++;
 136                 printf("USB");
 137                 printf("%d:   ", bus->seq);
 138                 ret = device_probe(bus);
 139                 if (ret == -ENODEV) {   /* No such device. */
 140                         puts("Port not available.\n");
 141                         controllers_initialized++;
 142                         continue;
 143                 }
 144
 145                 if (ret) {              /* Other error. */
 146                         printf("probe failed, error %d\n", ret);
 147                         continue;
 148                 }
 149                 /*
 150                  * lowlevel init is OK, now scan the bus for devices
 151                  * i.e. search HUBs and configure them
 152                  */
 153                 controllers_initialized++;
 154                 printf("scanning bus %d for devices... ", bus->seq);
 155                 debug("\n");
 156                 ret = usb_scan_bus(bus, true);
 157                 if (ret < 0)
 158                         printf("failed, error %d\n", ret);
 159                 else if (!ret)
 160                         printf("No USB Device found\n");
 161                 else
 162                         printf("%d USB Device(s) found\n", ret);
 163                 usb_started = true;
 164         }
 165
 166         debug("scan end\n");
 167         /* if we were not able to find at least one working bus, bail out */
 168         if (!count)
 169                 printf("No controllers found\n");
 170         else if (controllers_initialized == 0)
 171                 printf("USB error: all controllers failed lowlevel init\n");
 172
 173         return usb_started ? 0 : -1;
 174 }
 175
 176 int usb_reset_root_port(void)
 177 {
 178         return -ENOSYS;
 179 }
 180
 181 static struct usb_device *find_child_devnum(struct udevice *parent, int devnum)
 182 {
 183         struct usb_device *udev;
 184         struct udevice *dev;
 185
 186         if (!device_active(parent))
 187                 return NULL;
 188         udev = dev_get_parentdata(parent);
 189         if (udev->devnum == devnum)
 190                 return udev;
 191
 192         for (device_find_first_child(parent, &dev);
 193              dev;
 194              device_find_next_child(&dev)) {
 195                 udev = find_child_devnum(dev, devnum);
 196                 if (udev)
 197                         return udev;
 198         }
 199
 200         return NULL;
 201 }
 202
 203 struct usb_device *usb_get_dev_index(struct udevice *bus, int index)
 204 {
 205         struct udevice *hub;
 206         int devnum = index + 1; /* Addresses are allocated from 1 on USB */
 207
 208         device_find_first_child(bus, &hub);
 209         if (device_get_uclass_id(hub) == UCLASS_USB_HUB)
 210                 return find_child_devnum(hub, devnum);
 211
 212         return NULL;
 213 }
 214
 215 int usb_post_bind(struct udevice *dev)
 216 {
 217         /* Scan the bus for devices */
 218         return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false);
 219 }
 220
 221 int usb_port_reset(struct usb_device *parent, int portnr)
 222 {
 223         unsigned short portstatus;
 224         int ret;
 225
 226         debug("%s: start\n", __func__);
 227
 228         if (parent) {
 229                 /* reset the port for the second time */
 230                 assert(portnr > 0);
 231                 debug("%s: reset %d\n", __func__, portnr - 1);
 232                 ret = legacy_hub_port_reset(parent, portnr - 1, &portstatus);
 233                 if (ret < 0) {
 234                         printf("\n     Couldn't reset port %i\n", portnr);
 235                         return ret;
 236                 }
 237         } else {
 238                 debug("%s: reset root\n", __func__);
 239                 usb_reset_root_port();
 240         }
 241
 242         return 0;
 243 }
 244
 245 int usb_legacy_port_reset(struct usb_device *parent, int portnr)
 246 {
 247         return usb_port_reset(parent, portnr);
 248 }
 249
 250 int usb_scan_device(struct udevice *parent, int port,
 251                     enum usb_device_speed speed, struct udevice **devp)
 252 {
 253         struct udevice *dev;
 254         bool created = false;
 255         struct usb_dev_platdata *plat;
 256         struct usb_bus_priv *priv;
 257         struct usb_device *parent_udev;
 258         int ret;
 259         ALLOC_CACHE_ALIGN_BUFFER(struct usb_device, udev, 1);
 260         struct usb_interface_descriptor *iface = &udev->config.if_desc[0].desc;
 261
 262         *devp = NULL;
 263         memset(udev, '\0', sizeof(*udev));
 264         ret = usb_get_bus(parent, &udev->controller_dev);
 265         if (ret)
 266                 return ret;
 267         priv = dev_get_uclass_priv(udev->controller_dev);
 268
 269         /*
 270          * Somewhat nasty, this. We create a local device and use the normal
 271          * USB stack to read its descriptor. Then we know what type of device
 272          * to create for real.
 273          *
 274          * udev->dev is set to the parent, since we don't have a real device
 275          * yet. The USB stack should not access udev.dev anyway, except perhaps
 276          * to find the controller, and the controller will either be @parent,
 277          * or some parent of @parent.
 278          *
 279          * Another option might be to create the device as a generic USB
 280          * device, then morph it into the correct one when we know what it
 281          * should be. This means that a generic USB device would morph into
 282          * a network controller, or a USB flash stick, for example. However,
 283          * we don't support such morphing and it isn't clear that it would
 284          * be easy to do.
 285          *
 286          * Yet another option is to split out the USB stack parts of udev
 287          * into something like a 'struct urb' (as Linux does) which can exist
 288          * independently of any device. This feels cleaner, but calls for quite
 289          * a big change to the USB stack.
 290          *
 291          * For now, the approach is to set up an empty udev, read its
 292          * descriptor and assign it an address, then bind a real device and
 293          * stash the resulting information into the device's parent
 294          * platform data. Then when we probe it, usb_child_pre_probe() is called
 295          * and it will pull the information out of the stash.
 296          */
 297         udev->dev = parent;
 298         udev->speed = speed;
 299         udev->devnum = priv->next_addr + 1;
 300         udev->portnr = port;
 301         debug("Calling usb_setup_device(), portnr=%d\n", udev->portnr);
 302         parent_udev = device_get_uclass_id(parent) == UCLASS_USB_HUB ?
 303                 dev_get_parentdata(parent) : NULL;
 304         ret = usb_setup_device(udev, priv->desc_before_addr, parent_udev, port);
 305         debug("read_descriptor for '%s': ret=%d\n", parent->name, ret);
 306         if (ret)
 307                 return ret;
 308         ret = usb_find_child(parent, &udev->descriptor, iface, &dev);
 309         debug("** usb_find_child returns %d\n", ret);
 310
 311         /* TODO: Find a suitable driver and create the device */
 312         return -ENOENT;
 313 }
 314
 315 int usb_child_post_bind(struct udevice *dev)
 316 {
 317         struct usb_dev_platdata *plat = dev_get_parent_platdata(dev);
 318         const void *blob = gd->fdt_blob;
 319         int val;
 320
 321         if (dev->of_offset == -1)
 322                 return 0;
 323
 324         /* We only support matching a few things */
 325         val = fdtdec_get_int(blob, dev->of_offset, "usb,device-class", -1);
 326         if (val != -1) {
 327                 plat->id.match_flags |= USB_DEVICE_ID_MATCH_DEV_CLASS;
 328                 plat->id.bDeviceClass = val;
 329         }
 330         val = fdtdec_get_int(blob, dev->of_offset, "usb,interface-class", -1);
 331         if (val != -1) {
 332                 plat->id.match_flags |= USB_DEVICE_ID_MATCH_INT_CLASS;
 333                 plat->id.bInterfaceClass = val;
 334         }
 335
 336         return 0;
 337 }
 338
 339 int usb_get_bus(struct udevice *dev, struct udevice **busp)
 340 {
 341         struct udevice *bus;
 342
 343         *busp = NULL;
 344         for (bus = dev; bus && device_get_uclass_id(bus) != UCLASS_USB; )
 345                 bus = bus->parent;
 346         if (!bus) {
 347                 /* By design this cannot happen */
 348                 assert(bus);
 349                 debug("USB HUB '%s' does not have a controller\n", dev->name);
 350                 return -EXDEV;
 351         }
 352         *busp = bus;
 353
 354         return 0;
 355 }
 356
 357 int usb_child_pre_probe(struct udevice *dev)
 358 {
 359         struct udevice *bus;
 360         struct usb_device *udev = dev_get_parentdata(dev);
 361         struct usb_dev_platdata *plat = dev_get_parent_platdata(dev);
 362         int ret;
 363
 364         ret = usb_get_bus(dev, &bus);
 365         if (ret)
 366                 return ret;
 367         udev->controller_dev = bus;
 368         udev->dev = dev;
 369         udev->devnum = plat->devnum;
 370         udev->slot_id = plat->slot_id;
 371         udev->portnr = plat->portnr;
 372         udev->speed = plat->speed;
 373         debug("** device '%s': getting slot_id=%d\n", dev->name, plat->slot_id);
 374
 375         ret = usb_select_config(udev);
 376         if (ret)
 377                 return ret;
 378
 379         return 0;
 380 }
 381
 382 UCLASS_DRIVER(usb) = {
 383         .id             = UCLASS_USB,
 384         .name           = "usb",
 385         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 386         .post_bind      = usb_post_bind,
 387         .per_child_auto_alloc_size = sizeof(struct usb_device),
 388         .per_device_auto_alloc_size = sizeof(struct usb_bus_priv),
 389         .child_post_bind = usb_child_post_bind,
 390         .child_pre_probe = usb_child_pre_probe,
 391         .per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata),
 392 };