drivers/gpu/host1x/bus.c

   1 /*
   2  * Copyright (C) 2012 Avionic Design GmbH
   3  * Copyright (C) 2012-2013, NVIDIA Corporation
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <linux/host1x.h>
  19 #include <linux/of.h>
  20 #include <linux/slab.h>
  21 #include <linux/of_device.h>
  22
  23 #include "bus.h"
  24 #include "dev.h"
  25
  26 static DEFINE_MUTEX(clients_lock);
  27 static LIST_HEAD(clients);
  28
  29 static DEFINE_MUTEX(drivers_lock);
  30 static LIST_HEAD(drivers);
  31
  32 static DEFINE_MUTEX(devices_lock);
  33 static LIST_HEAD(devices);
  34
  35 struct host1x_subdev {
  36         struct host1x_client *client;
  37         struct device_node *np;
  38         struct list_head list;
  39 };
  40
  41 /**
  42  * host1x_subdev_add() - add a new subdevice with an associated device node
  43  */
  44 static int host1x_subdev_add(struct host1x_device *device,
  45                              struct device_node *np)
  46 {
  47         struct host1x_subdev *subdev;
  48
  49         subdev = kzalloc(sizeof(*subdev), GFP_KERNEL);
  50         if (!subdev)
  51                 return -ENOMEM;
  52
  53         INIT_LIST_HEAD(&subdev->list);
  54         subdev->np = of_node_get(np);
  55
  56         mutex_lock(&device->subdevs_lock);
  57         list_add_tail(&subdev->list, &device->subdevs);
  58         mutex_unlock(&device->subdevs_lock);
  59
  60         return 0;
  61 }
  62
  63 /**
  64  * host1x_subdev_del() - remove subdevice
  65  */
  66 static void host1x_subdev_del(struct host1x_subdev *subdev)
  67 {
  68         list_del(&subdev->list);
  69         of_node_put(subdev->np);
  70         kfree(subdev);
  71 }
  72
  73 /**
  74  * host1x_device_parse_dt() - scan device tree and add matching subdevices
  75  */
  76 static int host1x_device_parse_dt(struct host1x_device *device,
  77                                   struct host1x_driver *driver)
  78 {
  79         struct device_node *np;
  80         int err;
  81
  82         for_each_child_of_node(device->dev.parent->of_node, np) {
  83                 if (of_match_node(driver->subdevs, np) &&
  84                     of_device_is_available(np)) {
  85                         err = host1x_subdev_add(device, np);
  86                         if (err < 0)
  87                                 return err;
  88                 }
  89         }
  90
  91         return 0;
  92 }
  93
  94 static void host1x_subdev_register(struct host1x_device *device,
  95                                    struct host1x_subdev *subdev,
  96                                    struct host1x_client *client)
  97 {
  98         int err;
  99
 100         /*
 101          * Move the subdevice to the list of active (registered) subdevices
 102          * and associate it with a client. At the same time, associate the
 103          * client with its parent device.
 104          */
 105         mutex_lock(&device->subdevs_lock);
 106         mutex_lock(&device->clients_lock);
 107         list_move_tail(&client->list, &device->clients);
 108         list_move_tail(&subdev->list, &device->active);
 109         client->parent = &device->dev;
 110         subdev->client = client;
 111         mutex_unlock(&device->clients_lock);
 112         mutex_unlock(&device->subdevs_lock);
 113
 114         if (list_empty(&device->subdevs)) {
 115                 err = device_add(&device->dev);
 116                 if (err < 0)
 117                         dev_err(&device->dev, "failed to add: %d\n", err);
 118                 else
 119                         device->registered = true;
 120         }
 121 }
 122
 123 static void __host1x_subdev_unregister(struct host1x_device *device,
 124                                        struct host1x_subdev *subdev)
 125 {
 126         struct host1x_client *client = subdev->client;
 127
 128         /*
 129          * If all subdevices have been activated, we're about to remove the
 130          * first active subdevice, so unload the driver first.
 131          */
 132         if (list_empty(&device->subdevs)) {
 133                 if (device->registered) {
 134                         device->registered = false;
 135                         device_del(&device->dev);
 136                 }
 137         }
 138
 139         /*
 140          * Move the subdevice back to the list of idle subdevices and remove
 141          * it from list of clients.
 142          */
 143         mutex_lock(&device->clients_lock);
 144         subdev->client = NULL;
 145         client->parent = NULL;
 146         list_move_tail(&subdev->list, &device->subdevs);
 147         /*
 148          * XXX: Perhaps don't do this here, but rather explicitly remove it
 149          * when the device is about to be deleted.
 150          *
 151          * This is somewhat complicated by the fact that this function is
 152          * used to remove the subdevice when a client is unregistered but
 153          * also when the composite device is about to be removed.
 154          */
 155         list_del_init(&client->list);
 156         mutex_unlock(&device->clients_lock);
 157 }
 158
 159 static void host1x_subdev_unregister(struct host1x_device *device,
 160                                      struct host1x_subdev *subdev)
 161 {
 162         mutex_lock(&device->subdevs_lock);
 163         __host1x_subdev_unregister(device, subdev);
 164         mutex_unlock(&device->subdevs_lock);
 165 }
 166
 167 int host1x_device_init(struct host1x_device *device)
 168 {
 169         struct host1x_client *client;
 170         int err;
 171
 172         mutex_lock(&device->clients_lock);
 173
 174         list_for_each_entry(client, &device->clients, list) {
 175                 if (client->ops && client->ops->init) {
 176                         err = client->ops->init(client);
 177                         if (err < 0) {
 178                                 dev_err(&device->dev,
 179                                         "failed to initialize %s: %d\n",
 180                                         dev_name(client->dev), err);
 181                                 mutex_unlock(&device->clients_lock);
 182                                 return err;
 183                         }
 184                 }
 185         }
 186
 187         mutex_unlock(&device->clients_lock);
 188
 189         return 0;
 190 }
 191 EXPORT_SYMBOL(host1x_device_init);
 192
 193 int host1x_device_exit(struct host1x_device *device)
 194 {
 195         struct host1x_client *client;
 196         int err;
 197
 198         mutex_lock(&device->clients_lock);
 199
 200         list_for_each_entry_reverse(client, &device->clients, list) {
 201                 if (client->ops && client->ops->exit) {
 202                         err = client->ops->exit(client);
 203                         if (err < 0) {
 204                                 dev_err(&device->dev,
 205                                         "failed to cleanup %s: %d\n",
 206                                         dev_name(client->dev), err);
 207                                 mutex_unlock(&device->clients_lock);
 208                                 return err;
 209                         }
 210                 }
 211         }
 212
 213         mutex_unlock(&device->clients_lock);
 214
 215         return 0;
 216 }
 217 EXPORT_SYMBOL(host1x_device_exit);
 218
 219 static int host1x_add_client(struct host1x *host1x,
 220                              struct host1x_client *client)
 221 {
 222         struct host1x_device *device;
 223         struct host1x_subdev *subdev;
 224
 225         mutex_lock(&host1x->devices_lock);
 226
 227         list_for_each_entry(device, &host1x->devices, list) {
 228                 list_for_each_entry(subdev, &device->subdevs, list) {
 229                         if (subdev->np == client->dev->of_node) {
 230                                 host1x_subdev_register(device, subdev, client);
 231                                 mutex_unlock(&host1x->devices_lock);
 232                                 return 0;
 233                         }
 234                 }
 235         }
 236
 237         mutex_unlock(&host1x->devices_lock);
 238         return -ENODEV;
 239 }
 240
 241 static int host1x_del_client(struct host1x *host1x,
 242                              struct host1x_client *client)
 243 {
 244         struct host1x_device *device, *dt;
 245         struct host1x_subdev *subdev;
 246
 247         mutex_lock(&host1x->devices_lock);
 248
 249         list_for_each_entry_safe(device, dt, &host1x->devices, list) {
 250                 list_for_each_entry(subdev, &device->active, list) {
 251                         if (subdev->client == client) {
 252                                 host1x_subdev_unregister(device, subdev);
 253                                 mutex_unlock(&host1x->devices_lock);
 254                                 return 0;
 255                         }
 256                 }
 257         }
 258
 259         mutex_unlock(&host1x->devices_lock);
 260         return -ENODEV;
 261 }
 262
 263 static int host1x_device_match(struct device *dev, struct device_driver *drv)
 264 {
 265         return strcmp(dev_name(dev), drv->name) == 0;
 266 }
 267
 268 static int host1x_device_probe(struct device *dev)
 269 {
 270         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 271         struct host1x_device *device = to_host1x_device(dev);
 272
 273         if (driver->probe)
 274                 return driver->probe(device);
 275
 276         return 0;
 277 }
 278
 279 static int host1x_device_remove(struct device *dev)
 280 {
 281         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 282         struct host1x_device *device = to_host1x_device(dev);
 283
 284         if (driver->remove)
 285                 return driver->remove(device);
 286
 287         return 0;
 288 }
 289
 290 static void host1x_device_shutdown(struct device *dev)
 291 {
 292         struct host1x_driver *driver = to_host1x_driver(dev->driver);
 293         struct host1x_device *device = to_host1x_device(dev);
 294
 295         if (driver->shutdown)
 296                 driver->shutdown(device);
 297 }
 298
 299 static const struct dev_pm_ops host1x_device_pm_ops = {
 300         .suspend = pm_generic_suspend,
 301         .resume = pm_generic_resume,
 302         .freeze = pm_generic_freeze,
 303         .thaw = pm_generic_thaw,
 304         .poweroff = pm_generic_poweroff,
 305         .restore = pm_generic_restore,
 306 };
 307
 308 struct bus_type host1x_bus_type = {
 309         .name = "host1x",
 310         .match = host1x_device_match,
 311         .probe = host1x_device_probe,
 312         .remove = host1x_device_remove,
 313         .shutdown = host1x_device_shutdown,
 314         .pm = &host1x_device_pm_ops,
 315 };
 316
 317 static void __host1x_device_del(struct host1x_device *device)
 318 {
 319         struct host1x_subdev *subdev, *sd;
 320         struct host1x_client *client, *cl;
 321
 322         mutex_lock(&device->subdevs_lock);
 323
 324         /* unregister subdevices */
 325         list_for_each_entry_safe(subdev, sd, &device->active, list) {
 326                 /*
 327                  * host1x_subdev_unregister() will remove the client from
 328                  * any lists, so we'll need to manually add it back to the
 329                  * list of idle clients.
 330                  *
 331                  * XXX: Alternatively, perhaps don't remove the client from
 332                  * any lists in host1x_subdev_unregister() and instead do
 333                  * that explicitly from host1x_unregister_client()?
 334                  */
 335                 client = subdev->client;
 336
 337                 __host1x_subdev_unregister(device, subdev);
 338
 339                 /* add the client to the list of idle clients */
 340                 mutex_lock(&clients_lock);
 341                 list_add_tail(&client->list, &clients);
 342                 mutex_unlock(&clients_lock);
 343         }
 344
 345         /* remove subdevices */
 346         list_for_each_entry_safe(subdev, sd, &device->subdevs, list)
 347                 host1x_subdev_del(subdev);
 348
 349         mutex_unlock(&device->subdevs_lock);
 350
 351         /* move clients to idle list */
 352         mutex_lock(&clients_lock);
 353         mutex_lock(&device->clients_lock);
 354
 355         list_for_each_entry_safe(client, cl, &device->clients, list)
 356                 list_move_tail(&client->list, &clients);
 357
 358         mutex_unlock(&device->clients_lock);
 359         mutex_unlock(&clients_lock);
 360
 361         /* finally remove the device */
 362         list_del_init(&device->list);
 363 }
 364
 365 static void host1x_device_release(struct device *dev)
 366 {
 367         struct host1x_device *device = to_host1x_device(dev);
 368
 369         __host1x_device_del(device);
 370         kfree(device);
 371 }
 372
 373 static int host1x_device_add(struct host1x *host1x,
 374                              struct host1x_driver *driver)
 375 {
 376         struct host1x_client *client, *tmp;
 377         struct host1x_subdev *subdev;
 378         struct host1x_device *device;
 379         int err;
 380
 381         device = kzalloc(sizeof(*device), GFP_KERNEL);
 382         if (!device)
 383                 return -ENOMEM;
 384
 385         device_initialize(&device->dev);
 386
 387         mutex_init(&device->subdevs_lock);
 388         INIT_LIST_HEAD(&device->subdevs);
 389         INIT_LIST_HEAD(&device->active);
 390         mutex_init(&device->clients_lock);
 391         INIT_LIST_HEAD(&device->clients);
 392         INIT_LIST_HEAD(&device->list);
 393         device->driver = driver;
 394
 395         device->dev.coherent_dma_mask = host1x->dev->coherent_dma_mask;
 396         device->dev.dma_mask = &device->dev.coherent_dma_mask;
 397         dev_set_name(&device->dev, "%s", driver->driver.name);
 398         of_dma_configure(&device->dev, host1x->dev->of_node);
 399         device->dev.release = host1x_device_release;
 400         device->dev.bus = &host1x_bus_type;
 401         device->dev.parent = host1x->dev;
 402
 403         err = host1x_device_parse_dt(device, driver);
 404         if (err < 0) {
 405                 kfree(device);
 406                 return err;
 407         }
 408
 409         list_add_tail(&device->list, &host1x->devices);
 410
 411         mutex_lock(&clients_lock);
 412
 413         list_for_each_entry_safe(client, tmp, &clients, list) {
 414                 list_for_each_entry(subdev, &device->subdevs, list) {
 415                         if (subdev->np == client->dev->of_node) {
 416                                 host1x_subdev_register(device, subdev, client);
 417                                 break;
 418                         }
 419                 }
 420         }
 421
 422         mutex_unlock(&clients_lock);
 423
 424         return 0;
 425 }
 426
 427 /*
 428  * Removes a device by first unregistering any subdevices and then removing
 429  * itself from the list of devices.
 430  *
 431  * This function must be called with the host1x->devices_lock held.
 432  */
 433 static void host1x_device_del(struct host1x *host1x,
 434                               struct host1x_device *device)
 435 {
 436         if (device->registered) {
 437                 device->registered = false;
 438                 device_del(&device->dev);
 439         }
 440
 441         put_device(&device->dev);
 442 }
 443
 444 static void host1x_attach_driver(struct host1x *host1x,
 445                                  struct host1x_driver *driver)
 446 {
 447         struct host1x_device *device;
 448         int err;
 449
 450         mutex_lock(&host1x->devices_lock);
 451
 452         list_for_each_entry(device, &host1x->devices, list) {
 453                 if (device->driver == driver) {
 454                         mutex_unlock(&host1x->devices_lock);
 455                         return;
 456                 }
 457         }
 458
 459         err = host1x_device_add(host1x, driver);
 460         if (err < 0)
 461                 dev_err(host1x->dev, "failed to allocate device: %d\n", err);
 462
 463         mutex_unlock(&host1x->devices_lock);
 464 }
 465
 466 static void host1x_detach_driver(struct host1x *host1x,
 467                                  struct host1x_driver *driver)
 468 {
 469         struct host1x_device *device, *tmp;
 470
 471         mutex_lock(&host1x->devices_lock);
 472
 473         list_for_each_entry_safe(device, tmp, &host1x->devices, list)
 474                 if (device->driver == driver)
 475                         host1x_device_del(host1x, device);
 476
 477         mutex_unlock(&host1x->devices_lock);
 478 }
 479
 480 int host1x_register(struct host1x *host1x)
 481 {
 482         struct host1x_driver *driver;
 483
 484         mutex_lock(&devices_lock);
 485         list_add_tail(&host1x->list, &devices);
 486         mutex_unlock(&devices_lock);
 487
 488         mutex_lock(&drivers_lock);
 489
 490         list_for_each_entry(driver, &drivers, list)
 491                 host1x_attach_driver(host1x, driver);
 492
 493         mutex_unlock(&drivers_lock);
 494
 495         return 0;
 496 }
 497
 498 int host1x_unregister(struct host1x *host1x)
 499 {
 500         struct host1x_driver *driver;
 501
 502         mutex_lock(&drivers_lock);
 503
 504         list_for_each_entry(driver, &drivers, list)
 505                 host1x_detach_driver(host1x, driver);
 506
 507         mutex_unlock(&drivers_lock);
 508
 509         mutex_lock(&devices_lock);
 510         list_del_init(&host1x->list);
 511         mutex_unlock(&devices_lock);
 512
 513         return 0;
 514 }
 515
 516 int host1x_driver_register_full(struct host1x_driver *driver,
 517                                 struct module *owner)
 518 {
 519         struct host1x *host1x;
 520
 521         INIT_LIST_HEAD(&driver->list);
 522
 523         mutex_lock(&drivers_lock);
 524         list_add_tail(&driver->list, &drivers);
 525         mutex_unlock(&drivers_lock);
 526
 527         mutex_lock(&devices_lock);
 528
 529         list_for_each_entry(host1x, &devices, list)
 530                 host1x_attach_driver(host1x, driver);
 531
 532         mutex_unlock(&devices_lock);
 533
 534         driver->driver.bus = &host1x_bus_type;
 535         driver->driver.owner = owner;
 536
 537         return driver_register(&driver->driver);
 538 }
 539 EXPORT_SYMBOL(host1x_driver_register_full);
 540
 541 void host1x_driver_unregister(struct host1x_driver *driver)
 542 {
 543         driver_unregister(&driver->driver);
 544
 545         mutex_lock(&drivers_lock);
 546         list_del_init(&driver->list);
 547         mutex_unlock(&drivers_lock);
 548 }
 549 EXPORT_SYMBOL(host1x_driver_unregister);
 550
 551 int host1x_client_register(struct host1x_client *client)
 552 {
 553         struct host1x *host1x;
 554         int err;
 555
 556         mutex_lock(&devices_lock);
 557
 558         list_for_each_entry(host1x, &devices, list) {
 559                 err = host1x_add_client(host1x, client);
 560                 if (!err) {
 561                         mutex_unlock(&devices_lock);
 562                         return 0;
 563                 }
 564         }
 565
 566         mutex_unlock(&devices_lock);
 567
 568         mutex_lock(&clients_lock);
 569         list_add_tail(&client->list, &clients);
 570         mutex_unlock(&clients_lock);
 571
 572         return 0;
 573 }
 574 EXPORT_SYMBOL(host1x_client_register);
 575
 576 int host1x_client_unregister(struct host1x_client *client)
 577 {
 578         struct host1x_client *c;
 579         struct host1x *host1x;
 580         int err;
 581
 582         mutex_lock(&devices_lock);
 583
 584         list_for_each_entry(host1x, &devices, list) {
 585                 err = host1x_del_client(host1x, client);
 586                 if (!err) {
 587                         mutex_unlock(&devices_lock);
 588                         return 0;
 589                 }
 590         }
 591
 592         mutex_unlock(&devices_lock);
 593         mutex_lock(&clients_lock);
 594
 595         list_for_each_entry(c, &clients, list) {
 596                 if (c == client) {
 597                         list_del_init(&c->list);
 598                         break;
 599                 }
 600         }
 601
 602         mutex_unlock(&clients_lock);
 603
 604         return 0;
 605 }
 606 EXPORT_SYMBOL(host1x_client_unregister);