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->parent = &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->parent = 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_dma_configure(struct device *dev)
 309 {
 310         return of_dma_configure(dev, dev->of_node, true);
 311 }
 312
 313 static const struct dev_pm_ops host1x_device_pm_ops = {
 314         .suspend = pm_generic_suspend,
 315         .resume = pm_generic_resume,
 316         .freeze = pm_generic_freeze,
 317         .thaw = pm_generic_thaw,
 318         .poweroff = pm_generic_poweroff,
 319         .restore = pm_generic_restore,
 320 };
 321
 322 struct bus_type host1x_bus_type = {
 323         .name = "host1x",
 324         .match = host1x_device_match,
 325         .dma_configure = host1x_dma_configure,
 326         .pm = &host1x_device_pm_ops,
 327 };
 328
 329 static void __host1x_device_del(struct host1x_device *device)
 330 {
 331         struct host1x_subdev *subdev, *sd;
 332         struct host1x_client *client, *cl;
 333
 334         mutex_lock(&device->subdevs_lock);
 335
 336         /* unregister subdevices */
 337         list_for_each_entry_safe(subdev, sd, &device->active, list) {
 338                 /*
 339                  * host1x_subdev_unregister() will remove the client from
 340                  * any lists, so we'll need to manually add it back to the
 341                  * list of idle clients.
 342                  *
 343                  * XXX: Alternatively, perhaps don't remove the client from
 344                  * any lists in host1x_subdev_unregister() and instead do
 345                  * that explicitly from host1x_unregister_client()?
 346                  */
 347                 client = subdev->client;
 348
 349                 __host1x_subdev_unregister(device, subdev);
 350
 351                 /* add the client to the list of idle clients */
 352                 mutex_lock(&clients_lock);
 353                 list_add_tail(&client->list, &clients);
 354                 mutex_unlock(&clients_lock);
 355         }
 356
 357         /* remove subdevices */
 358         list_for_each_entry_safe(subdev, sd, &device->subdevs, list)
 359                 host1x_subdev_del(subdev);
 360
 361         mutex_unlock(&device->subdevs_lock);
 362
 363         /* move clients to idle list */
 364         mutex_lock(&clients_lock);
 365         mutex_lock(&device->clients_lock);
 366
 367         list_for_each_entry_safe(client, cl, &device->clients, list)
 368                 list_move_tail(&client->list, &clients);
 369
 370         mutex_unlock(&device->clients_lock);
 371         mutex_unlock(&clients_lock);
 372
 373         /* finally remove the device */
 374         list_del_init(&device->list);
 375 }
 376
 377 static void host1x_device_release(struct device *dev)
 378 {
 379         struct host1x_device *device = to_host1x_device(dev);
 380
 381         __host1x_device_del(device);
 382         kfree(device);
 383 }
 384
 385 static int host1x_device_add(struct host1x *host1x,
 386                              struct host1x_driver *driver)
 387 {
 388         struct host1x_client *client, *tmp;
 389         struct host1x_subdev *subdev;
 390         struct host1x_device *device;
 391         int err;
 392
 393         device = kzalloc(sizeof(*device), GFP_KERNEL);
 394         if (!device)
 395                 return -ENOMEM;
 396
 397         device_initialize(&device->dev);
 398
 399         mutex_init(&device->subdevs_lock);
 400         INIT_LIST_HEAD(&device->subdevs);
 401         INIT_LIST_HEAD(&device->active);
 402         mutex_init(&device->clients_lock);
 403         INIT_LIST_HEAD(&device->clients);
 404         INIT_LIST_HEAD(&device->list);
 405         device->driver = driver;
 406
 407         device->dev.coherent_dma_mask = host1x->dev->coherent_dma_mask;
 408         device->dev.dma_mask = &device->dev.coherent_dma_mask;
 409         dev_set_name(&device->dev, "%s", driver->driver.name);
 410         device->dev.release = host1x_device_release;
 411         device->dev.of_node = host1x->dev->of_node;
 412         device->dev.bus = &host1x_bus_type;
 413         device->dev.parent = host1x->dev;
 414
 415         of_dma_configure(&device->dev, host1x->dev->of_node, true);
 416
 417         err = host1x_device_parse_dt(device, driver);
 418         if (err < 0) {
 419                 kfree(device);
 420                 return err;
 421         }
 422
 423         list_add_tail(&device->list, &host1x->devices);
 424
 425         mutex_lock(&clients_lock);
 426
 427         list_for_each_entry_safe(client, tmp, &clients, list) {
 428                 list_for_each_entry(subdev, &device->subdevs, list) {
 429                         if (subdev->np == client->dev->of_node) {
 430                                 host1x_subdev_register(device, subdev, client);
 431                                 break;
 432                         }
 433                 }
 434         }
 435
 436         mutex_unlock(&clients_lock);
 437
 438         return 0;
 439 }
 440
 441 /*
 442  * Removes a device by first unregistering any subdevices and then removing
 443  * itself from the list of devices.
 444  *
 445  * This function must be called with the host1x->devices_lock held.
 446  */
 447 static void host1x_device_del(struct host1x *host1x,
 448                               struct host1x_device *device)
 449 {
 450         if (device->registered) {
 451                 device->registered = false;
 452                 device_del(&device->dev);
 453         }
 454
 455         put_device(&device->dev);
 456 }
 457
 458 static void host1x_attach_driver(struct host1x *host1x,
 459                                  struct host1x_driver *driver)
 460 {
 461         struct host1x_device *device;
 462         int err;
 463
 464         mutex_lock(&host1x->devices_lock);
 465
 466         list_for_each_entry(device, &host1x->devices, list) {
 467                 if (device->driver == driver) {
 468                         mutex_unlock(&host1x->devices_lock);
 469                         return;
 470                 }
 471         }
 472
 473         err = host1x_device_add(host1x, driver);
 474         if (err < 0)
 475                 dev_err(host1x->dev, "failed to allocate device: %d\n", err);
 476
 477         mutex_unlock(&host1x->devices_lock);
 478 }
 479
 480 static void host1x_detach_driver(struct host1x *host1x,
 481                                  struct host1x_driver *driver)
 482 {
 483         struct host1x_device *device, *tmp;
 484
 485         mutex_lock(&host1x->devices_lock);
 486
 487         list_for_each_entry_safe(device, tmp, &host1x->devices, list)
 488                 if (device->driver == driver)
 489                         host1x_device_del(host1x, device);
 490
 491         mutex_unlock(&host1x->devices_lock);
 492 }
 493
 494 static int host1x_devices_show(struct seq_file *s, void *data)
 495 {
 496         struct host1x *host1x = s->private;
 497         struct host1x_device *device;
 498
 499         mutex_lock(&host1x->devices_lock);
 500
 501         list_for_each_entry(device, &host1x->devices, list) {
 502                 struct host1x_subdev *subdev;
 503
 504                 seq_printf(s, "%s\n", dev_name(&device->dev));
 505
 506                 mutex_lock(&device->subdevs_lock);
 507
 508                 list_for_each_entry(subdev, &device->active, list)
 509                         seq_printf(s, "  %pOFf: %s\n", subdev->np,
 510                                    dev_name(subdev->client->dev));
 511
 512                 list_for_each_entry(subdev, &device->subdevs, list)
 513                         seq_printf(s, "  %pOFf:\n", subdev->np);
 514
 515                 mutex_unlock(&device->subdevs_lock);
 516         }
 517
 518         mutex_unlock(&host1x->devices_lock);
 519
 520         return 0;
 521 }
 522 DEFINE_SHOW_ATTRIBUTE(host1x_devices);
 523
 524 /**
 525  * host1x_register() - register a host1x controller
 526  * @host1x: host1x controller
 527  *
 528  * The host1x controller driver uses this to register a host1x controller with
 529  * the infrastructure. Note that all Tegra SoC generations have only ever come
 530  * with a single host1x instance, so this function is somewhat academic.
 531  */
 532 int host1x_register(struct host1x *host1x)
 533 {
 534         struct host1x_driver *driver;
 535
 536         mutex_lock(&devices_lock);
 537         list_add_tail(&host1x->list, &devices);
 538         mutex_unlock(&devices_lock);
 539
 540         mutex_lock(&drivers_lock);
 541
 542         list_for_each_entry(driver, &drivers, list)
 543                 host1x_attach_driver(host1x, driver);
 544
 545         mutex_unlock(&drivers_lock);
 546
 547         debugfs_create_file("devices", S_IRUGO, host1x->debugfs, host1x,
 548                             &host1x_devices_fops);
 549
 550         return 0;
 551 }
 552
 553 /**
 554  * host1x_unregister() - unregister a host1x controller
 555  * @host1x: host1x controller
 556  *
 557  * The host1x controller driver uses this to remove a host1x controller from
 558  * the infrastructure.
 559  */
 560 int host1x_unregister(struct host1x *host1x)
 561 {
 562         struct host1x_driver *driver;
 563
 564         mutex_lock(&drivers_lock);
 565
 566         list_for_each_entry(driver, &drivers, list)
 567                 host1x_detach_driver(host1x, driver);
 568
 569         mutex_unlock(&drivers_lock);
 570
 571         mutex_lock(&devices_lock);
 572         list_del_init(&host1x->list);
 573         mutex_unlock(&devices_lock);
 574
 575         return 0;
 576 }
 577
 578 static int host1x_device_probe(struct device *dev)
 579 {
 580         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 581         struct host1x_device *device = to_host1x_device(dev);
 582
 583         if (driver->probe)
 584                 return driver->probe(device);
 585
 586         return 0;
 587 }
 588
 589 static int host1x_device_remove(struct device *dev)
 590 {
 591         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 592         struct host1x_device *device = to_host1x_device(dev);
 593
 594         if (driver->remove)
 595                 return driver->remove(device);
 596
 597         return 0;
 598 }
 599
 600 static void host1x_device_shutdown(struct device *dev)
 601 {
 602         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 603         struct host1x_device *device = to_host1x_device(dev);
 604
 605         if (driver->shutdown)
 606                 driver->shutdown(device);
 607 }
 608
 609 /**
 610  * host1x_driver_register_full() - register a host1x driver
 611  * @driver: host1x driver
 612  * @owner: owner module
 613  *
 614  * Drivers for host1x logical devices call this function to register a driver
 615  * with the infrastructure. Note that since these drive logical devices, the
 616  * registration of the driver actually triggers tho logical device creation.
 617  * A logical device will be created for each host1x instance.
 618  */
 619 int host1x_driver_register_full(struct host1x_driver *driver,
 620                                 struct module *owner)
 621 {
 622         struct host1x *host1x;
 623
 624         INIT_LIST_HEAD(&driver->list);
 625
 626         mutex_lock(&drivers_lock);
 627         list_add_tail(&driver->list, &drivers);
 628         mutex_unlock(&drivers_lock);
 629
 630         mutex_lock(&devices_lock);
 631
 632         list_for_each_entry(host1x, &devices, list)
 633                 host1x_attach_driver(host1x, driver);
 634
 635         mutex_unlock(&devices_lock);
 636
 637         driver->driver.bus = &host1x_bus_type;
 638         driver->driver.owner = owner;
 639         driver->driver.probe = host1x_device_probe;
 640         driver->driver.remove = host1x_device_remove;
 641         driver->driver.shutdown = host1x_device_shutdown;
 642
 643         return driver_register(&driver->driver);
 644 }
 645 EXPORT_SYMBOL(host1x_driver_register_full);
 646
 647 /**
 648  * host1x_driver_unregister() - unregister a host1x driver
 649  * @driver: host1x driver
 650  *
 651  * Unbinds the driver from each of the host1x logical devices that it is
 652  * bound to, effectively removing the subsystem devices that they represent.
 653  */
 654 void host1x_driver_unregister(struct host1x_driver *driver)
 655 {
 656         driver_unregister(&driver->driver);
 657
 658         mutex_lock(&drivers_lock);
 659         list_del_init(&driver->list);
 660         mutex_unlock(&drivers_lock);
 661 }
 662 EXPORT_SYMBOL(host1x_driver_unregister);
 663
 664 /**
 665  * host1x_client_register() - register a host1x client
 666  * @client: host1x client
 667  *
 668  * Registers a host1x client with each host1x controller instance. Note that
 669  * each client will only match their parent host1x controller and will only be
 670  * associated with that instance. Once all clients have been registered with
 671  * their parent host1x controller, the infrastructure will set up the logical
 672  * device and call host1x_device_init(), which will in turn call each client's
 673  * &host1x_client_ops.init implementation.
 674  */
 675 int host1x_client_register(struct host1x_client *client)
 676 {
 677         struct host1x *host1x;
 678         int err;
 679
 680         mutex_lock(&devices_lock);
 681
 682         list_for_each_entry(host1x, &devices, list) {
 683                 err = host1x_add_client(host1x, client);
 684                 if (!err) {
 685                         mutex_unlock(&devices_lock);
 686                         return 0;
 687                 }
 688         }
 689
 690         mutex_unlock(&devices_lock);
 691
 692         mutex_lock(&clients_lock);
 693         list_add_tail(&client->list, &clients);
 694         mutex_unlock(&clients_lock);
 695
 696         return 0;
 697 }
 698 EXPORT_SYMBOL(host1x_client_register);
 699
 700 /**
 701  * host1x_client_unregister() - unregister a host1x client
 702  * @client: host1x client
 703  *
 704  * Removes a host1x client from its host1x controller instance. If a logical
 705  * device has already been initialized, it will be torn down.
 706  */
 707 int host1x_client_unregister(struct host1x_client *client)
 708 {
 709         struct host1x_client *c;
 710         struct host1x *host1x;
 711         int err;
 712
 713         mutex_lock(&devices_lock);
 714
 715         list_for_each_entry(host1x, &devices, list) {
 716                 err = host1x_del_client(host1x, client);
 717                 if (!err) {
 718                         mutex_unlock(&devices_lock);
 719                         return 0;
 720                 }
 721         }
 722
 723         mutex_unlock(&devices_lock);
 724         mutex_lock(&clients_lock);
 725
 726         list_for_each_entry(c, &clients, list) {
 727                 if (c == client) {
 728                         list_del_init(&c->list);
 729                         break;
 730                 }
 731         }
 732
 733         mutex_unlock(&clients_lock);
 734
 735         return 0;
 736 }
 737 EXPORT_SYMBOL(host1x_client_unregister);