drivers/gpu/host1x/bus.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2012 Avionic Design GmbH
   4  * Copyright (C) 2012-2013, NVIDIA Corporation
   5  */
   6
   7 #include <linux/debugfs.h>
   8 #include <linux/host1x.h>
   9 #include <linux/of.h>
  10 #include <linux/seq_file.h>
  11 #include <linux/slab.h>
  12 #include <linux/of_device.h>
  13
  14 #include "bus.h"
  15 #include "dev.h"
  16
  17 static DEFINE_MUTEX(clients_lock);
  18 static LIST_HEAD(clients);
  19
  20 static DEFINE_MUTEX(drivers_lock);
  21 static LIST_HEAD(drivers);
  22
  23 static DEFINE_MUTEX(devices_lock);
  24 static LIST_HEAD(devices);
  25
  26 struct host1x_subdev {
  27         struct host1x_client *client;
  28         struct device_node *np;
  29         struct list_head list;
  30 };
  31
  32 /**
  33  * host1x_subdev_add() - add a new subdevice with an associated device node
  34  * @device: host1x device to add the subdevice to
  35  * @np: device node
  36  */
  37 static int host1x_subdev_add(struct host1x_device *device,
  38                              struct host1x_driver *driver,
  39                              struct device_node *np)
  40 {
  41         struct host1x_subdev *subdev;
  42         struct device_node *child;
  43         int err;
  44
  45         subdev = kzalloc(sizeof(*subdev), GFP_KERNEL);
  46         if (!subdev)
  47                 return -ENOMEM;
  48
  49         INIT_LIST_HEAD(&subdev->list);
  50         subdev->np = of_node_get(np);
  51
  52         mutex_lock(&device->subdevs_lock);
  53         list_add_tail(&subdev->list, &device->subdevs);
  54         mutex_unlock(&device->subdevs_lock);
  55
  56         /* recursively add children */
  57         for_each_child_of_node(np, child) {
  58                 if (of_match_node(driver->subdevs, child) &&
  59                     of_device_is_available(child)) {
  60                         err = host1x_subdev_add(device, driver, child);
  61                         if (err < 0) {
  62                                 /* XXX cleanup? */
  63                                 of_node_put(child);
  64                                 return err;
  65                         }
  66                 }
  67         }
  68
  69         return 0;
  70 }
  71
  72 /**
  73  * host1x_subdev_del() - remove subdevice
  74  * @subdev: subdevice to remove
  75  */
  76 static void host1x_subdev_del(struct host1x_subdev *subdev)
  77 {
  78         list_del(&subdev->list);
  79         of_node_put(subdev->np);
  80         kfree(subdev);
  81 }
  82
  83 /**
  84  * host1x_device_parse_dt() - scan device tree and add matching subdevices
  85  * @device: host1x logical device
  86  * @driver: host1x driver
  87  */
  88 static int host1x_device_parse_dt(struct host1x_device *device,
  89                                   struct host1x_driver *driver)
  90 {
  91         struct device_node *np;
  92         int err;
  93
  94         for_each_child_of_node(device->dev.parent->of_node, np) {
  95                 if (of_match_node(driver->subdevs, np) &&
  96                     of_device_is_available(np)) {
  97                         err = host1x_subdev_add(device, driver, np);
  98                         if (err < 0) {
  99                                 of_node_put(np);
 100                                 return err;
 101                         }
 102                 }
 103         }
 104
 105         return 0;
 106 }
 107
 108 static void host1x_subdev_register(struct host1x_device *device,
 109                                    struct host1x_subdev *subdev,
 110                                    struct host1x_client *client)
 111 {
 112         int err;
 113
 114         /*
 115          * Move the subdevice to the list of active (registered) subdevices
 116          * and associate it with a client. At the same time, associate the
 117          * client with its parent device.
 118          */
 119         mutex_lock(&device->subdevs_lock);
 120         mutex_lock(&device->clients_lock);
 121         list_move_tail(&client->list, &device->clients);
 122         list_move_tail(&subdev->list, &device->active);
 123         client->host = &device->dev;
 124         subdev->client = client;
 125         mutex_unlock(&device->clients_lock);
 126         mutex_unlock(&device->subdevs_lock);
 127
 128         if (list_empty(&device->subdevs)) {
 129                 err = device_add(&device->dev);
 130                 if (err < 0)
 131                         dev_err(&device->dev, "failed to add: %d\n", err);
 132                 else
 133                         device->registered = true;
 134         }
 135 }
 136
 137 static void __host1x_subdev_unregister(struct host1x_device *device,
 138                                        struct host1x_subdev *subdev)
 139 {
 140         struct host1x_client *client = subdev->client;
 141
 142         /*
 143          * If all subdevices have been activated, we're about to remove the
 144          * first active subdevice, so unload the driver first.
 145          */
 146         if (list_empty(&device->subdevs)) {
 147                 if (device->registered) {
 148                         device->registered = false;
 149                         device_del(&device->dev);
 150                 }
 151         }
 152
 153         /*
 154          * Move the subdevice back to the list of idle subdevices and remove
 155          * it from list of clients.
 156          */
 157         mutex_lock(&device->clients_lock);
 158         subdev->client = NULL;
 159         client->host = NULL;
 160         list_move_tail(&subdev->list, &device->subdevs);
 161         /*
 162          * XXX: Perhaps don't do this here, but rather explicitly remove it
 163          * when the device is about to be deleted.
 164          *
 165          * This is somewhat complicated by the fact that this function is
 166          * used to remove the subdevice when a client is unregistered but
 167          * also when the composite device is about to be removed.
 168          */
 169         list_del_init(&client->list);
 170         mutex_unlock(&device->clients_lock);
 171 }
 172
 173 static void host1x_subdev_unregister(struct host1x_device *device,
 174                                      struct host1x_subdev *subdev)
 175 {
 176         mutex_lock(&device->subdevs_lock);
 177         __host1x_subdev_unregister(device, subdev);
 178         mutex_unlock(&device->subdevs_lock);
 179 }
 180
 181 /**
 182  * host1x_device_init() - initialize a host1x logical device
 183  * @device: host1x logical device
 184  *
 185  * The driver for the host1x logical device can call this during execution of
 186  * its &host1x_driver.probe implementation to initialize each of its clients.
 187  * The client drivers access the subsystem specific driver data using the
 188  * &host1x_client.parent field and driver data associated with it (usually by
 189  * calling dev_get_drvdata()).
 190  */
 191 int host1x_device_init(struct host1x_device *device)
 192 {
 193         struct host1x_client *client;
 194         int err;
 195
 196         mutex_lock(&device->clients_lock);
 197
 198         list_for_each_entry(client, &device->clients, list) {
 199                 if (client->ops && client->ops->init) {
 200                         err = client->ops->init(client);
 201                         if (err < 0) {
 202                                 dev_err(&device->dev,
 203                                         "failed to initialize %s: %d\n",
 204                                         dev_name(client->dev), err);
 205                                 goto teardown;
 206                         }
 207                 }
 208         }
 209
 210         mutex_unlock(&device->clients_lock);
 211
 212         return 0;
 213
 214 teardown:
 215         list_for_each_entry_continue_reverse(client, &device->clients, list)
 216                 if (client->ops->exit)
 217                         client->ops->exit(client);
 218
 219         mutex_unlock(&device->clients_lock);
 220         return err;
 221 }
 222 EXPORT_SYMBOL(host1x_device_init);
 223
 224 /**
 225  * host1x_device_exit() - uninitialize host1x logical device
 226  * @device: host1x logical device
 227  *
 228  * When the driver for a host1x logical device is unloaded, it can call this
 229  * function to tear down each of its clients. Typically this is done after a
 230  * subsystem-specific data structure is removed and the functionality can no
 231  * longer be used.
 232  */
 233 int host1x_device_exit(struct host1x_device *device)
 234 {
 235         struct host1x_client *client;
 236         int err;
 237
 238         mutex_lock(&device->clients_lock);
 239
 240         list_for_each_entry_reverse(client, &device->clients, list) {
 241                 if (client->ops && client->ops->exit) {
 242                         err = client->ops->exit(client);
 243                         if (err < 0) {
 244                                 dev_err(&device->dev,
 245                                         "failed to cleanup %s: %d\n",
 246                                         dev_name(client->dev), err);
 247                                 mutex_unlock(&device->clients_lock);
 248                                 return err;
 249                         }
 250                 }
 251         }
 252
 253         mutex_unlock(&device->clients_lock);
 254
 255         return 0;
 256 }
 257 EXPORT_SYMBOL(host1x_device_exit);
 258
 259 static int host1x_add_client(struct host1x *host1x,
 260                              struct host1x_client *client)
 261 {
 262         struct host1x_device *device;
 263         struct host1x_subdev *subdev;
 264
 265         mutex_lock(&host1x->devices_lock);
 266
 267         list_for_each_entry(device, &host1x->devices, list) {
 268                 list_for_each_entry(subdev, &device->subdevs, list) {
 269                         if (subdev->np == client->dev->of_node) {
 270                                 host1x_subdev_register(device, subdev, client);
 271                                 mutex_unlock(&host1x->devices_lock);
 272                                 return 0;
 273                         }
 274                 }
 275         }
 276
 277         mutex_unlock(&host1x->devices_lock);
 278         return -ENODEV;
 279 }
 280
 281 static int host1x_del_client(struct host1x *host1x,
 282                              struct host1x_client *client)
 283 {
 284         struct host1x_device *device, *dt;
 285         struct host1x_subdev *subdev;
 286
 287         mutex_lock(&host1x->devices_lock);
 288
 289         list_for_each_entry_safe(device, dt, &host1x->devices, list) {
 290                 list_for_each_entry(subdev, &device->active, list) {
 291                         if (subdev->client == client) {
 292                                 host1x_subdev_unregister(device, subdev);
 293                                 mutex_unlock(&host1x->devices_lock);
 294                                 return 0;
 295                         }
 296                 }
 297         }
 298
 299         mutex_unlock(&host1x->devices_lock);
 300         return -ENODEV;
 301 }
 302
 303 static int host1x_device_match(struct device *dev, struct device_driver *drv)
 304 {
 305         return strcmp(dev_name(dev), drv->name) == 0;
 306 }
 307
 308 static int host1x_device_uevent(struct device *dev,
 309                                 struct kobj_uevent_env *env)
 310 {
 311         struct device_node *np = dev->parent->of_node;
 312         unsigned int count = 0;
 313         struct property *p;
 314         const char *compat;
 315
 316         /*
 317          * This duplicates most of of_device_uevent(), but the latter cannot
 318          * be called from modules and operates on dev->of_node, which is not
 319          * available in this case.
 320          *
 321          * Note that this is really only needed for backwards compatibility
 322          * with libdrm, which parses this information from sysfs and will
 323          * fail if it can't find the OF_FULLNAME, specifically.
 324          */
 325         add_uevent_var(env, "OF_NAME=%pOFn", np);
 326         add_uevent_var(env, "OF_FULLNAME=%pOF", np);
 327
 328         of_property_for_each_string(np, "compatible", p, compat) {
 329                 add_uevent_var(env, "OF_COMPATIBLE_%u=%s", count, compat);
 330                 count++;
 331         }
 332
 333         add_uevent_var(env, "OF_COMPATIBLE_N=%u", count);
 334
 335         return 0;
 336 }
 337
 338 static int host1x_dma_configure(struct device *dev)
 339 {
 340         return of_dma_configure(dev, dev->of_node, true);
 341 }
 342
 343 static const struct dev_pm_ops host1x_device_pm_ops = {
 344         .suspend = pm_generic_suspend,
 345         .resume = pm_generic_resume,
 346         .freeze = pm_generic_freeze,
 347         .thaw = pm_generic_thaw,
 348         .poweroff = pm_generic_poweroff,
 349         .restore = pm_generic_restore,
 350 };
 351
 352 struct bus_type host1x_bus_type = {
 353         .name = "host1x",
 354         .match = host1x_device_match,
 355         .uevent = host1x_device_uevent,
 356         .dma_configure = host1x_dma_configure,
 357         .pm = &host1x_device_pm_ops,
 358 };
 359
 360 static void __host1x_device_del(struct host1x_device *device)
 361 {
 362         struct host1x_subdev *subdev, *sd;
 363         struct host1x_client *client, *cl;
 364
 365         mutex_lock(&device->subdevs_lock);
 366
 367         /* unregister subdevices */
 368         list_for_each_entry_safe(subdev, sd, &device->active, list) {
 369                 /*
 370                  * host1x_subdev_unregister() will remove the client from
 371                  * any lists, so we'll need to manually add it back to the
 372                  * list of idle clients.
 373                  *
 374                  * XXX: Alternatively, perhaps don't remove the client from
 375                  * any lists in host1x_subdev_unregister() and instead do
 376                  * that explicitly from host1x_unregister_client()?
 377                  */
 378                 client = subdev->client;
 379
 380                 __host1x_subdev_unregister(device, subdev);
 381
 382                 /* add the client to the list of idle clients */
 383                 mutex_lock(&clients_lock);
 384                 list_add_tail(&client->list, &clients);
 385                 mutex_unlock(&clients_lock);
 386         }
 387
 388         /* remove subdevices */
 389         list_for_each_entry_safe(subdev, sd, &device->subdevs, list)
 390                 host1x_subdev_del(subdev);
 391
 392         mutex_unlock(&device->subdevs_lock);
 393
 394         /* move clients to idle list */
 395         mutex_lock(&clients_lock);
 396         mutex_lock(&device->clients_lock);
 397
 398         list_for_each_entry_safe(client, cl, &device->clients, list)
 399                 list_move_tail(&client->list, &clients);
 400
 401         mutex_unlock(&device->clients_lock);
 402         mutex_unlock(&clients_lock);
 403
 404         /* finally remove the device */
 405         list_del_init(&device->list);
 406 }
 407
 408 static void host1x_device_release(struct device *dev)
 409 {
 410         struct host1x_device *device = to_host1x_device(dev);
 411
 412         __host1x_device_del(device);
 413         kfree(device);
 414 }
 415
 416 static int host1x_device_add(struct host1x *host1x,
 417                              struct host1x_driver *driver)
 418 {
 419         struct host1x_client *client, *tmp;
 420         struct host1x_subdev *subdev;
 421         struct host1x_device *device;
 422         int err;
 423
 424         device = kzalloc(sizeof(*device), GFP_KERNEL);
 425         if (!device)
 426                 return -ENOMEM;
 427
 428         device_initialize(&device->dev);
 429
 430         mutex_init(&device->subdevs_lock);
 431         INIT_LIST_HEAD(&device->subdevs);
 432         INIT_LIST_HEAD(&device->active);
 433         mutex_init(&device->clients_lock);
 434         INIT_LIST_HEAD(&device->clients);
 435         INIT_LIST_HEAD(&device->list);
 436         device->driver = driver;
 437
 438         device->dev.coherent_dma_mask = host1x->dev->coherent_dma_mask;
 439         device->dev.dma_mask = &device->dev.coherent_dma_mask;
 440         dev_set_name(&device->dev, "%s", driver->driver.name);
 441         device->dev.release = host1x_device_release;
 442         device->dev.bus = &host1x_bus_type;
 443         device->dev.parent = host1x->dev;
 444
 445         of_dma_configure(&device->dev, host1x->dev->of_node, true);
 446
 447         device->dev.dma_parms = &device->dma_parms;
 448         dma_set_max_seg_size(&device->dev, UINT_MAX);
 449
 450         err = host1x_device_parse_dt(device, driver);
 451         if (err < 0) {
 452                 kfree(device);
 453                 return err;
 454         }
 455
 456         list_add_tail(&device->list, &host1x->devices);
 457
 458         mutex_lock(&clients_lock);
 459
 460         list_for_each_entry_safe(client, tmp, &clients, list) {
 461                 list_for_each_entry(subdev, &device->subdevs, list) {
 462                         if (subdev->np == client->dev->of_node) {
 463                                 host1x_subdev_register(device, subdev, client);
 464                                 break;
 465                         }
 466                 }
 467         }
 468
 469         mutex_unlock(&clients_lock);
 470
 471         return 0;
 472 }
 473
 474 /*
 475  * Removes a device by first unregistering any subdevices and then removing
 476  * itself from the list of devices.
 477  *
 478  * This function must be called with the host1x->devices_lock held.
 479  */
 480 static void host1x_device_del(struct host1x *host1x,
 481                               struct host1x_device *device)
 482 {
 483         if (device->registered) {
 484                 device->registered = false;
 485                 device_del(&device->dev);
 486         }
 487
 488         put_device(&device->dev);
 489 }
 490
 491 static void host1x_attach_driver(struct host1x *host1x,
 492                                  struct host1x_driver *driver)
 493 {
 494         struct host1x_device *device;
 495         int err;
 496
 497         mutex_lock(&host1x->devices_lock);
 498
 499         list_for_each_entry(device, &host1x->devices, list) {
 500                 if (device->driver == driver) {
 501                         mutex_unlock(&host1x->devices_lock);
 502                         return;
 503                 }
 504         }
 505
 506         err = host1x_device_add(host1x, driver);
 507         if (err < 0)
 508                 dev_err(host1x->dev, "failed to allocate device: %d\n", err);
 509
 510         mutex_unlock(&host1x->devices_lock);
 511 }
 512
 513 static void host1x_detach_driver(struct host1x *host1x,
 514                                  struct host1x_driver *driver)
 515 {
 516         struct host1x_device *device, *tmp;
 517
 518         mutex_lock(&host1x->devices_lock);
 519
 520         list_for_each_entry_safe(device, tmp, &host1x->devices, list)
 521                 if (device->driver == driver)
 522                         host1x_device_del(host1x, device);
 523
 524         mutex_unlock(&host1x->devices_lock);
 525 }
 526
 527 static int host1x_devices_show(struct seq_file *s, void *data)
 528 {
 529         struct host1x *host1x = s->private;
 530         struct host1x_device *device;
 531
 532         mutex_lock(&host1x->devices_lock);
 533
 534         list_for_each_entry(device, &host1x->devices, list) {
 535                 struct host1x_subdev *subdev;
 536
 537                 seq_printf(s, "%s\n", dev_name(&device->dev));
 538
 539                 mutex_lock(&device->subdevs_lock);
 540
 541                 list_for_each_entry(subdev, &device->active, list)
 542                         seq_printf(s, "  %pOFf: %s\n", subdev->np,
 543                                    dev_name(subdev->client->dev));
 544
 545                 list_for_each_entry(subdev, &device->subdevs, list)
 546                         seq_printf(s, "  %pOFf:\n", subdev->np);
 547
 548                 mutex_unlock(&device->subdevs_lock);
 549         }
 550
 551         mutex_unlock(&host1x->devices_lock);
 552
 553         return 0;
 554 }
 555 DEFINE_SHOW_ATTRIBUTE(host1x_devices);
 556
 557 /**
 558  * host1x_register() - register a host1x controller
 559  * @host1x: host1x controller
 560  *
 561  * The host1x controller driver uses this to register a host1x controller with
 562  * the infrastructure. Note that all Tegra SoC generations have only ever come
 563  * with a single host1x instance, so this function is somewhat academic.
 564  */
 565 int host1x_register(struct host1x *host1x)
 566 {
 567         struct host1x_driver *driver;
 568
 569         mutex_lock(&devices_lock);
 570         list_add_tail(&host1x->list, &devices);
 571         mutex_unlock(&devices_lock);
 572
 573         mutex_lock(&drivers_lock);
 574
 575         list_for_each_entry(driver, &drivers, list)
 576                 host1x_attach_driver(host1x, driver);
 577
 578         mutex_unlock(&drivers_lock);
 579
 580         debugfs_create_file("devices", S_IRUGO, host1x->debugfs, host1x,
 581                             &host1x_devices_fops);
 582
 583         return 0;
 584 }
 585
 586 /**
 587  * host1x_unregister() - unregister a host1x controller
 588  * @host1x: host1x controller
 589  *
 590  * The host1x controller driver uses this to remove a host1x controller from
 591  * the infrastructure.
 592  */
 593 int host1x_unregister(struct host1x *host1x)
 594 {
 595         struct host1x_driver *driver;
 596
 597         mutex_lock(&drivers_lock);
 598
 599         list_for_each_entry(driver, &drivers, list)
 600                 host1x_detach_driver(host1x, driver);
 601
 602         mutex_unlock(&drivers_lock);
 603
 604         mutex_lock(&devices_lock);
 605         list_del_init(&host1x->list);
 606         mutex_unlock(&devices_lock);
 607
 608         return 0;
 609 }
 610
 611 static int host1x_device_probe(struct device *dev)
 612 {
 613         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 614         struct host1x_device *device = to_host1x_device(dev);
 615
 616         if (driver->probe)
 617                 return driver->probe(device);
 618
 619         return 0;
 620 }
 621
 622 static int host1x_device_remove(struct device *dev)
 623 {
 624         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 625         struct host1x_device *device = to_host1x_device(dev);
 626
 627         if (driver->remove)
 628                 return driver->remove(device);
 629
 630         return 0;
 631 }
 632
 633 static void host1x_device_shutdown(struct device *dev)
 634 {
 635         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 636         struct host1x_device *device = to_host1x_device(dev);
 637
 638         if (driver->shutdown)
 639                 driver->shutdown(device);
 640 }
 641
 642 /**
 643  * host1x_driver_register_full() - register a host1x driver
 644  * @driver: host1x driver
 645  * @owner: owner module
 646  *
 647  * Drivers for host1x logical devices call this function to register a driver
 648  * with the infrastructure. Note that since these drive logical devices, the
 649  * registration of the driver actually triggers tho logical device creation.
 650  * A logical device will be created for each host1x instance.
 651  */
 652 int host1x_driver_register_full(struct host1x_driver *driver,
 653                                 struct module *owner)
 654 {
 655         struct host1x *host1x;
 656
 657         INIT_LIST_HEAD(&driver->list);
 658
 659         mutex_lock(&drivers_lock);
 660         list_add_tail(&driver->list, &drivers);
 661         mutex_unlock(&drivers_lock);
 662
 663         mutex_lock(&devices_lock);
 664
 665         list_for_each_entry(host1x, &devices, list)
 666                 host1x_attach_driver(host1x, driver);
 667
 668         mutex_unlock(&devices_lock);
 669
 670         driver->driver.bus = &host1x_bus_type;
 671         driver->driver.owner = owner;
 672         driver->driver.probe = host1x_device_probe;
 673         driver->driver.remove = host1x_device_remove;
 674         driver->driver.shutdown = host1x_device_shutdown;
 675
 676         return driver_register(&driver->driver);
 677 }
 678 EXPORT_SYMBOL(host1x_driver_register_full);
 679
 680 /**
 681  * host1x_driver_unregister() - unregister a host1x driver
 682  * @driver: host1x driver
 683  *
 684  * Unbinds the driver from each of the host1x logical devices that it is
 685  * bound to, effectively removing the subsystem devices that they represent.
 686  */
 687 void host1x_driver_unregister(struct host1x_driver *driver)
 688 {
 689         driver_unregister(&driver->driver);
 690
 691         mutex_lock(&drivers_lock);
 692         list_del_init(&driver->list);
 693         mutex_unlock(&drivers_lock);
 694 }
 695 EXPORT_SYMBOL(host1x_driver_unregister);
 696
 697 /**
 698  * host1x_client_register() - register a host1x client
 699  * @client: host1x client
 700  *
 701  * Registers a host1x client with each host1x controller instance. Note that
 702  * each client will only match their parent host1x controller and will only be
 703  * associated with that instance. Once all clients have been registered with
 704  * their parent host1x controller, the infrastructure will set up the logical
 705  * device and call host1x_device_init(), which will in turn call each client's
 706  * &host1x_client_ops.init implementation.
 707  */
 708 int host1x_client_register(struct host1x_client *client)
 709 {
 710         struct host1x *host1x;
 711         int err;
 712
 713         INIT_LIST_HEAD(&client->list);
 714         mutex_init(&client->lock);
 715         client->usecount = 0;
 716
 717         mutex_lock(&devices_lock);
 718
 719         list_for_each_entry(host1x, &devices, list) {
 720                 err = host1x_add_client(host1x, client);
 721                 if (!err) {
 722                         mutex_unlock(&devices_lock);
 723                         return 0;
 724                 }
 725         }
 726
 727         mutex_unlock(&devices_lock);
 728
 729         mutex_lock(&clients_lock);
 730         list_add_tail(&client->list, &clients);
 731         mutex_unlock(&clients_lock);
 732
 733         return 0;
 734 }
 735 EXPORT_SYMBOL(host1x_client_register);
 736
 737 /**
 738  * host1x_client_unregister() - unregister a host1x client
 739  * @client: host1x client
 740  *
 741  * Removes a host1x client from its host1x controller instance. If a logical
 742  * device has already been initialized, it will be torn down.
 743  */
 744 int host1x_client_unregister(struct host1x_client *client)
 745 {
 746         struct host1x_client *c;
 747         struct host1x *host1x;
 748         int err;
 749
 750         mutex_lock(&devices_lock);
 751
 752         list_for_each_entry(host1x, &devices, list) {
 753                 err = host1x_del_client(host1x, client);
 754                 if (!err) {
 755                         mutex_unlock(&devices_lock);
 756                         return 0;
 757                 }
 758         }
 759
 760         mutex_unlock(&devices_lock);
 761         mutex_lock(&clients_lock);
 762
 763         list_for_each_entry(c, &clients, list) {
 764                 if (c == client) {
 765                         list_del_init(&c->list);
 766                         break;
 767                 }
 768         }
 769
 770         mutex_unlock(&clients_lock);
 771
 772         return 0;
 773 }
 774 EXPORT_SYMBOL(host1x_client_unregister);
 775
 776 int host1x_client_suspend(struct host1x_client *client)
 777 {
 778         int err = 0;
 779
 780         mutex_lock(&client->lock);
 781
 782         if (client->usecount == 1) {
 783                 if (client->ops && client->ops->suspend) {
 784                         err = client->ops->suspend(client);
 785                         if (err < 0)
 786                                 goto unlock;
 787                 }
 788         }
 789
 790         client->usecount--;
 791         dev_dbg(client->dev, "use count: %u\n", client->usecount);
 792
 793         if (client->parent) {
 794                 err = host1x_client_suspend(client->parent);
 795                 if (err < 0)
 796                         goto resume;
 797         }
 798
 799         goto unlock;
 800
 801 resume:
 802         if (client->usecount == 0)
 803                 if (client->ops && client->ops->resume)
 804                         client->ops->resume(client);
 805
 806         client->usecount++;
 807 unlock:
 808         mutex_unlock(&client->lock);
 809         return err;
 810 }
 811 EXPORT_SYMBOL(host1x_client_suspend);
 812
 813 int host1x_client_resume(struct host1x_client *client)
 814 {
 815         int err = 0;
 816
 817         mutex_lock(&client->lock);
 818
 819         if (client->parent) {
 820                 err = host1x_client_resume(client->parent);
 821                 if (err < 0)
 822                         goto unlock;
 823         }
 824
 825         if (client->usecount == 0) {
 826                 if (client->ops && client->ops->resume) {
 827                         err = client->ops->resume(client);
 828                         if (err < 0)
 829                                 goto suspend;
 830                 }
 831         }
 832
 833         client->usecount++;
 834         dev_dbg(client->dev, "use count: %u\n", client->usecount);
 835
 836         goto unlock;
 837
 838 suspend:
 839         if (client->parent)
 840                 host1x_client_suspend(client->parent);
 841 unlock:
 842         mutex_unlock(&client->lock);
 843         return err;
 844 }
 845 EXPORT_SYMBOL(host1x_client_resume);