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 const struct dev_pm_ops host1x_device_pm_ops = {
 339         .suspend = pm_generic_suspend,
 340         .resume = pm_generic_resume,
 341         .freeze = pm_generic_freeze,
 342         .thaw = pm_generic_thaw,
 343         .poweroff = pm_generic_poweroff,
 344         .restore = pm_generic_restore,
 345 };
 346
 347 struct bus_type host1x_bus_type = {
 348         .name = "host1x",
 349         .match = host1x_device_match,
 350         .uevent = host1x_device_uevent,
 351         .pm = &host1x_device_pm_ops,
 352 };
 353
 354 static void __host1x_device_del(struct host1x_device *device)
 355 {
 356         struct host1x_subdev *subdev, *sd;
 357         struct host1x_client *client, *cl;
 358
 359         mutex_lock(&device->subdevs_lock);
 360
 361         /* unregister subdevices */
 362         list_for_each_entry_safe(subdev, sd, &device->active, list) {
 363                 /*
 364                  * host1x_subdev_unregister() will remove the client from
 365                  * any lists, so we'll need to manually add it back to the
 366                  * list of idle clients.
 367                  *
 368                  * XXX: Alternatively, perhaps don't remove the client from
 369                  * any lists in host1x_subdev_unregister() and instead do
 370                  * that explicitly from host1x_unregister_client()?
 371                  */
 372                 client = subdev->client;
 373
 374                 __host1x_subdev_unregister(device, subdev);
 375
 376                 /* add the client to the list of idle clients */
 377                 mutex_lock(&clients_lock);
 378                 list_add_tail(&client->list, &clients);
 379                 mutex_unlock(&clients_lock);
 380         }
 381
 382         /* remove subdevices */
 383         list_for_each_entry_safe(subdev, sd, &device->subdevs, list)
 384                 host1x_subdev_del(subdev);
 385
 386         mutex_unlock(&device->subdevs_lock);
 387
 388         /* move clients to idle list */
 389         mutex_lock(&clients_lock);
 390         mutex_lock(&device->clients_lock);
 391
 392         list_for_each_entry_safe(client, cl, &device->clients, list)
 393                 list_move_tail(&client->list, &clients);
 394
 395         mutex_unlock(&device->clients_lock);
 396         mutex_unlock(&clients_lock);
 397
 398         /* finally remove the device */
 399         list_del_init(&device->list);
 400 }
 401
 402 static void host1x_device_release(struct device *dev)
 403 {
 404         struct host1x_device *device = to_host1x_device(dev);
 405
 406         __host1x_device_del(device);
 407         kfree(device);
 408 }
 409
 410 static int host1x_device_add(struct host1x *host1x,
 411                              struct host1x_driver *driver)
 412 {
 413         struct host1x_client *client, *tmp;
 414         struct host1x_subdev *subdev;
 415         struct host1x_device *device;
 416         int err;
 417
 418         device = kzalloc(sizeof(*device), GFP_KERNEL);
 419         if (!device)
 420                 return -ENOMEM;
 421
 422         device_initialize(&device->dev);
 423
 424         mutex_init(&device->subdevs_lock);
 425         INIT_LIST_HEAD(&device->subdevs);
 426         INIT_LIST_HEAD(&device->active);
 427         mutex_init(&device->clients_lock);
 428         INIT_LIST_HEAD(&device->clients);
 429         INIT_LIST_HEAD(&device->list);
 430         device->driver = driver;
 431
 432         device->dev.coherent_dma_mask = host1x->dev->coherent_dma_mask;
 433         device->dev.dma_mask = &device->dev.coherent_dma_mask;
 434         dev_set_name(&device->dev, "%s", driver->driver.name);
 435         device->dev.release = host1x_device_release;
 436         device->dev.bus = &host1x_bus_type;
 437         device->dev.parent = host1x->dev;
 438
 439         device->dev.dma_parms = &device->dma_parms;
 440         dma_set_max_seg_size(&device->dev, UINT_MAX);
 441
 442         err = host1x_device_parse_dt(device, driver);
 443         if (err < 0) {
 444                 kfree(device);
 445                 return err;
 446         }
 447
 448         list_add_tail(&device->list, &host1x->devices);
 449
 450         mutex_lock(&clients_lock);
 451
 452         list_for_each_entry_safe(client, tmp, &clients, list) {
 453                 list_for_each_entry(subdev, &device->subdevs, list) {
 454                         if (subdev->np == client->dev->of_node) {
 455                                 host1x_subdev_register(device, subdev, client);
 456                                 break;
 457                         }
 458                 }
 459         }
 460
 461         mutex_unlock(&clients_lock);
 462
 463         return 0;
 464 }
 465
 466 /*
 467  * Removes a device by first unregistering any subdevices and then removing
 468  * itself from the list of devices.
 469  *
 470  * This function must be called with the host1x->devices_lock held.
 471  */
 472 static void host1x_device_del(struct host1x *host1x,
 473                               struct host1x_device *device)
 474 {
 475         if (device->registered) {
 476                 device->registered = false;
 477                 device_del(&device->dev);
 478         }
 479
 480         put_device(&device->dev);
 481 }
 482
 483 static void host1x_attach_driver(struct host1x *host1x,
 484                                  struct host1x_driver *driver)
 485 {
 486         struct host1x_device *device;
 487         int err;
 488
 489         mutex_lock(&host1x->devices_lock);
 490
 491         list_for_each_entry(device, &host1x->devices, list) {
 492                 if (device->driver == driver) {
 493                         mutex_unlock(&host1x->devices_lock);
 494                         return;
 495                 }
 496         }
 497
 498         err = host1x_device_add(host1x, driver);
 499         if (err < 0)
 500                 dev_err(host1x->dev, "failed to allocate device: %d\n", err);
 501
 502         mutex_unlock(&host1x->devices_lock);
 503 }
 504
 505 static void host1x_detach_driver(struct host1x *host1x,
 506                                  struct host1x_driver *driver)
 507 {
 508         struct host1x_device *device, *tmp;
 509
 510         mutex_lock(&host1x->devices_lock);
 511
 512         list_for_each_entry_safe(device, tmp, &host1x->devices, list)
 513                 if (device->driver == driver)
 514                         host1x_device_del(host1x, device);
 515
 516         mutex_unlock(&host1x->devices_lock);
 517 }
 518
 519 static int host1x_devices_show(struct seq_file *s, void *data)
 520 {
 521         struct host1x *host1x = s->private;
 522         struct host1x_device *device;
 523
 524         mutex_lock(&host1x->devices_lock);
 525
 526         list_for_each_entry(device, &host1x->devices, list) {
 527                 struct host1x_subdev *subdev;
 528
 529                 seq_printf(s, "%s\n", dev_name(&device->dev));
 530
 531                 mutex_lock(&device->subdevs_lock);
 532
 533                 list_for_each_entry(subdev, &device->active, list)
 534                         seq_printf(s, "  %pOFf: %s\n", subdev->np,
 535                                    dev_name(subdev->client->dev));
 536
 537                 list_for_each_entry(subdev, &device->subdevs, list)
 538                         seq_printf(s, "  %pOFf:\n", subdev->np);
 539
 540                 mutex_unlock(&device->subdevs_lock);
 541         }
 542
 543         mutex_unlock(&host1x->devices_lock);
 544
 545         return 0;
 546 }
 547 DEFINE_SHOW_ATTRIBUTE(host1x_devices);
 548
 549 /**
 550  * host1x_register() - register a host1x controller
 551  * @host1x: host1x controller
 552  *
 553  * The host1x controller driver uses this to register a host1x controller with
 554  * the infrastructure. Note that all Tegra SoC generations have only ever come
 555  * with a single host1x instance, so this function is somewhat academic.
 556  */
 557 int host1x_register(struct host1x *host1x)
 558 {
 559         struct host1x_driver *driver;
 560
 561         mutex_lock(&devices_lock);
 562         list_add_tail(&host1x->list, &devices);
 563         mutex_unlock(&devices_lock);
 564
 565         mutex_lock(&drivers_lock);
 566
 567         list_for_each_entry(driver, &drivers, list)
 568                 host1x_attach_driver(host1x, driver);
 569
 570         mutex_unlock(&drivers_lock);
 571
 572         debugfs_create_file("devices", S_IRUGO, host1x->debugfs, host1x,
 573                             &host1x_devices_fops);
 574
 575         return 0;
 576 }
 577
 578 /**
 579  * host1x_unregister() - unregister a host1x controller
 580  * @host1x: host1x controller
 581  *
 582  * The host1x controller driver uses this to remove a host1x controller from
 583  * the infrastructure.
 584  */
 585 int host1x_unregister(struct host1x *host1x)
 586 {
 587         struct host1x_driver *driver;
 588
 589         mutex_lock(&drivers_lock);
 590
 591         list_for_each_entry(driver, &drivers, list)
 592                 host1x_detach_driver(host1x, driver);
 593
 594         mutex_unlock(&drivers_lock);
 595
 596         mutex_lock(&devices_lock);
 597         list_del_init(&host1x->list);
 598         mutex_unlock(&devices_lock);
 599
 600         return 0;
 601 }
 602
 603 static int host1x_device_probe(struct device *dev)
 604 {
 605         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 606         struct host1x_device *device = to_host1x_device(dev);
 607
 608         if (driver->probe)
 609                 return driver->probe(device);
 610
 611         return 0;
 612 }
 613
 614 static int host1x_device_remove(struct device *dev)
 615 {
 616         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 617         struct host1x_device *device = to_host1x_device(dev);
 618
 619         if (driver->remove)
 620                 return driver->remove(device);
 621
 622         return 0;
 623 }
 624
 625 static void host1x_device_shutdown(struct device *dev)
 626 {
 627         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 628         struct host1x_device *device = to_host1x_device(dev);
 629
 630         if (driver->shutdown)
 631                 driver->shutdown(device);
 632 }
 633
 634 /**
 635  * host1x_driver_register_full() - register a host1x driver
 636  * @driver: host1x driver
 637  * @owner: owner module
 638  *
 639  * Drivers for host1x logical devices call this function to register a driver
 640  * with the infrastructure. Note that since these drive logical devices, the
 641  * registration of the driver actually triggers tho logical device creation.
 642  * A logical device will be created for each host1x instance.
 643  */
 644 int host1x_driver_register_full(struct host1x_driver *driver,
 645                                 struct module *owner)
 646 {
 647         struct host1x *host1x;
 648
 649         INIT_LIST_HEAD(&driver->list);
 650
 651         mutex_lock(&drivers_lock);
 652         list_add_tail(&driver->list, &drivers);
 653         mutex_unlock(&drivers_lock);
 654
 655         mutex_lock(&devices_lock);
 656
 657         list_for_each_entry(host1x, &devices, list)
 658                 host1x_attach_driver(host1x, driver);
 659
 660         mutex_unlock(&devices_lock);
 661
 662         driver->driver.bus = &host1x_bus_type;
 663         driver->driver.owner = owner;
 664         driver->driver.probe = host1x_device_probe;
 665         driver->driver.remove = host1x_device_remove;
 666         driver->driver.shutdown = host1x_device_shutdown;
 667
 668         return driver_register(&driver->driver);
 669 }
 670 EXPORT_SYMBOL(host1x_driver_register_full);
 671
 672 /**
 673  * host1x_driver_unregister() - unregister a host1x driver
 674  * @driver: host1x driver
 675  *
 676  * Unbinds the driver from each of the host1x logical devices that it is
 677  * bound to, effectively removing the subsystem devices that they represent.
 678  */
 679 void host1x_driver_unregister(struct host1x_driver *driver)
 680 {
 681         struct host1x *host1x;
 682
 683         driver_unregister(&driver->driver);
 684
 685         mutex_lock(&devices_lock);
 686
 687         list_for_each_entry(host1x, &devices, list)
 688                 host1x_detach_driver(host1x, driver);
 689
 690         mutex_unlock(&devices_lock);
 691
 692         mutex_lock(&drivers_lock);
 693         list_del_init(&driver->list);
 694         mutex_unlock(&drivers_lock);
 695 }
 696 EXPORT_SYMBOL(host1x_driver_unregister);
 697
 698 /**
 699  * __host1x_client_init() - initialize a host1x client
 700  * @client: host1x client
 701  * @key: lock class key for the client-specific mutex
 702  */
 703 void __host1x_client_init(struct host1x_client *client, struct lock_class_key *key)
 704 {
 705         INIT_LIST_HEAD(&client->list);
 706         __mutex_init(&client->lock, "host1x client lock", key);
 707         client->usecount = 0;
 708 }
 709 EXPORT_SYMBOL(__host1x_client_init);
 710
 711 /**
 712  * host1x_client_exit() - uninitialize a host1x client
 713  * @client: host1x client
 714  */
 715 void host1x_client_exit(struct host1x_client *client)
 716 {
 717         mutex_destroy(&client->lock);
 718 }
 719 EXPORT_SYMBOL(host1x_client_exit);
 720
 721 /**
 722  * __host1x_client_register() - register a host1x client
 723  * @client: host1x client
 724  * @key: lock class key for the client-specific mutex
 725  *
 726  * Registers a host1x client with each host1x controller instance. Note that
 727  * each client will only match their parent host1x controller and will only be
 728  * associated with that instance. Once all clients have been registered with
 729  * their parent host1x controller, the infrastructure will set up the logical
 730  * device and call host1x_device_init(), which will in turn call each client's
 731  * &host1x_client_ops.init implementation.
 732  */
 733 int __host1x_client_register(struct host1x_client *client)
 734 {
 735         struct host1x *host1x;
 736         int err;
 737
 738         mutex_lock(&devices_lock);
 739
 740         list_for_each_entry(host1x, &devices, list) {
 741                 err = host1x_add_client(host1x, client);
 742                 if (!err) {
 743                         mutex_unlock(&devices_lock);
 744                         return 0;
 745                 }
 746         }
 747
 748         mutex_unlock(&devices_lock);
 749
 750         mutex_lock(&clients_lock);
 751         list_add_tail(&client->list, &clients);
 752         mutex_unlock(&clients_lock);
 753
 754         return 0;
 755 }
 756 EXPORT_SYMBOL(__host1x_client_register);
 757
 758 /**
 759  * host1x_client_unregister() - unregister a host1x client
 760  * @client: host1x client
 761  *
 762  * Removes a host1x client from its host1x controller instance. If a logical
 763  * device has already been initialized, it will be torn down.
 764  */
 765 int host1x_client_unregister(struct host1x_client *client)
 766 {
 767         struct host1x_client *c;
 768         struct host1x *host1x;
 769         int err;
 770
 771         mutex_lock(&devices_lock);
 772
 773         list_for_each_entry(host1x, &devices, list) {
 774                 err = host1x_del_client(host1x, client);
 775                 if (!err) {
 776                         mutex_unlock(&devices_lock);
 777                         return 0;
 778                 }
 779         }
 780
 781         mutex_unlock(&devices_lock);
 782         mutex_lock(&clients_lock);
 783
 784         list_for_each_entry(c, &clients, list) {
 785                 if (c == client) {
 786                         list_del_init(&c->list);
 787                         break;
 788                 }
 789         }
 790
 791         mutex_unlock(&clients_lock);
 792
 793         return 0;
 794 }
 795 EXPORT_SYMBOL(host1x_client_unregister);
 796
 797 int host1x_client_suspend(struct host1x_client *client)
 798 {
 799         int err = 0;
 800
 801         mutex_lock(&client->lock);
 802
 803         if (client->usecount == 1) {
 804                 if (client->ops && client->ops->suspend) {
 805                         err = client->ops->suspend(client);
 806                         if (err < 0)
 807                                 goto unlock;
 808                 }
 809         }
 810
 811         client->usecount--;
 812         dev_dbg(client->dev, "use count: %u\n", client->usecount);
 813
 814         if (client->parent) {
 815                 err = host1x_client_suspend(client->parent);
 816                 if (err < 0)
 817                         goto resume;
 818         }
 819
 820         goto unlock;
 821
 822 resume:
 823         if (client->usecount == 0)
 824                 if (client->ops && client->ops->resume)
 825                         client->ops->resume(client);
 826
 827         client->usecount++;
 828 unlock:
 829         mutex_unlock(&client->lock);
 830         return err;
 831 }
 832 EXPORT_SYMBOL(host1x_client_suspend);
 833
 834 int host1x_client_resume(struct host1x_client *client)
 835 {
 836         int err = 0;
 837
 838         mutex_lock(&client->lock);
 839
 840         if (client->parent) {
 841                 err = host1x_client_resume(client->parent);
 842                 if (err < 0)
 843                         goto unlock;
 844         }
 845
 846         if (client->usecount == 0) {
 847                 if (client->ops && client->ops->resume) {
 848                         err = client->ops->resume(client);
 849                         if (err < 0)
 850                                 goto suspend;
 851                 }
 852         }
 853
 854         client->usecount++;
 855         dev_dbg(client->dev, "use count: %u\n", client->usecount);
 856
 857         goto unlock;
 858
 859 suspend:
 860         if (client->parent)
 861                 host1x_client_suspend(client->parent);
 862 unlock:
 863         mutex_unlock(&client->lock);
 864         return err;
 865 }
 866 EXPORT_SYMBOL(host1x_client_resume);