drivers/gpu/drm/nouveau/nouveau_drm.c

   1 /*
   2  * Copyright 2012 Red Hat Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: Ben Skeggs
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/pci.h>
  27
  28 #include <core/device.h>
  29 #include <core/client.h>
  30 #include <core/gpuobj.h>
  31 #include <core/class.h>
  32
  33 #include <subdev/device.h>
  34 #include <subdev/vm.h>
  35
  36 #include "nouveau_drm.h"
  37 #include "nouveau_dma.h"
  38 #include "nouveau_agp.h"
  39 #include "nouveau_abi16.h"
  40 #include "nouveau_fbcon.h"
  41 #include "nouveau_fence.h"
  42
  43 #include "nouveau_ttm.h"
  44
  45 int __devinit nouveau_pci_probe(struct pci_dev *, const struct pci_device_id *);
  46 void nouveau_pci_remove(struct pci_dev *);
  47 int nouveau_pci_suspend(struct pci_dev *, pm_message_t);
  48 int nouveau_pci_resume(struct pci_dev *);
  49 int __init nouveau_init(struct pci_driver *);
  50 void __exit nouveau_exit(struct pci_driver *);
  51
  52 int nouveau_load(struct drm_device *, unsigned long);
  53 int nouveau_unload(struct drm_device *);
  54
  55 MODULE_PARM_DESC(config, "option string to pass to driver core");
  56 static char *nouveau_config;
  57 module_param_named(config, nouveau_config, charp, 0400);
  58
  59 MODULE_PARM_DESC(debug, "debug string to pass to driver core");
  60 static char *nouveau_debug;
  61 module_param_named(debug, nouveau_debug, charp, 0400);
  62
  63 MODULE_PARM_DESC(noaccel, "disable kernel/abi16 acceleration");
  64 static int nouveau_noaccel = 0;
  65 module_param_named(noaccel, nouveau_noaccel, int, 0400);
  66
  67 static u64
  68 nouveau_name(struct pci_dev *pdev)
  69 {
  70         u64 name = (u64)pci_domain_nr(pdev->bus) << 32;
  71         name |= pdev->bus->number << 16;
  72         name |= PCI_SLOT(pdev->devfn) << 8;
  73         return name | PCI_FUNC(pdev->devfn);
  74 }
  75
  76 static int
  77 nouveau_cli_create(struct pci_dev *pdev, u32 name, int size, void **pcli)
  78 {
  79         struct nouveau_cli *cli;
  80         int ret;
  81
  82         ret = nouveau_client_create_(name, nouveau_name(pdev), nouveau_config,
  83                                      nouveau_debug, size, pcli);
  84         cli = *pcli;
  85         if (ret)
  86                 return ret;
  87
  88         mutex_init(&cli->mutex);
  89         return 0;
  90 }
  91
  92 static void
  93 nouveau_cli_destroy(struct nouveau_cli *cli)
  94 {
  95         struct nouveau_object *client = nv_object(cli);
  96         nouveau_vm_ref(NULL, &cli->base.vm, NULL);
  97         nouveau_client_fini(&cli->base, false);
  98         atomic_set(&client->refcount, 1);
  99         nouveau_object_ref(NULL, &client);
 100 }
 101
 102 static void
 103 nouveau_accel_fini(struct nouveau_drm *drm)
 104 {
 105         nouveau_gpuobj_ref(NULL, &drm->notify);
 106         nouveau_channel_del(&drm->channel);
 107         if (drm->fence)
 108                 nouveau_fence(drm)->dtor(drm);
 109 }
 110
 111 static void
 112 nouveau_accel_init(struct nouveau_drm *drm)
 113 {
 114         struct nouveau_device *device = nv_device(drm->device);
 115         struct nouveau_object *object;
 116         int ret;
 117
 118         if (nouveau_noaccel)
 119                 return;
 120
 121         /* initialise synchronisation routines */
 122         if      (device->card_type < NV_10) ret = nv04_fence_create(drm);
 123         else if (device->chipset   <  0x84) ret = nv10_fence_create(drm);
 124         else if (device->card_type < NV_C0) ret = nv84_fence_create(drm);
 125         else                                ret = nvc0_fence_create(drm);
 126         if (ret) {
 127                 NV_ERROR(drm, "failed to initialise sync subsystem, %d\n", ret);
 128                 nouveau_accel_fini(drm);
 129                 return;
 130         }
 131
 132         ret = nouveau_channel_new(drm, &drm->client, NVDRM_DEVICE, NVDRM_CHAN,
 133                                   NvDmaFB, NvDmaTT, &drm->channel);
 134         if (ret) {
 135                 NV_ERROR(drm, "failed to create kernel channel, %d\n", ret);
 136                 nouveau_accel_fini(drm);
 137                 return;
 138         }
 139
 140         if (device->card_type < NV_C0) {
 141                 ret = nouveau_gpuobj_new(drm->device, NULL, 32, 0, 0,
 142                                         &drm->notify);
 143                 if (ret) {
 144                         NV_ERROR(drm, "failed to allocate notifier, %d\n", ret);
 145                         nouveau_accel_fini(drm);
 146                         return;
 147                 }
 148
 149                 ret = nouveau_object_new(nv_object(drm),
 150                                          drm->channel->handle, NvNotify0,
 151                                          0x003d, &(struct nv_dma_class) {
 152                                                 .flags = NV_DMA_TARGET_VRAM |
 153                                                          NV_DMA_ACCESS_RDWR,
 154                                                 .start = drm->notify->addr,
 155                                                 .limit = drm->notify->addr + 31
 156                                                 }, sizeof(struct nv_dma_class),
 157                                          &object);
 158                 if (ret) {
 159                         nouveau_accel_fini(drm);
 160                         return;
 161                 }
 162         }
 163
 164
 165         nouveau_bo_move_init(drm->channel);
 166 }
 167
 168 static int __devinit
 169 nouveau_drm_probe(struct pci_dev *pdev, const struct pci_device_id *pent)
 170 {
 171         struct nouveau_device *device;
 172         struct apertures_struct *aper;
 173         bool boot = false;
 174         int ret;
 175
 176         /* remove conflicting drivers (vesafb, efifb etc) */
 177         aper = alloc_apertures(3);
 178         if (!aper)
 179                 return -ENOMEM;
 180
 181         aper->ranges[0].base = pci_resource_start(pdev, 1);
 182         aper->ranges[0].size = pci_resource_len(pdev, 1);
 183         aper->count = 1;
 184
 185         if (pci_resource_len(pdev, 2)) {
 186                 aper->ranges[aper->count].base = pci_resource_start(pdev, 2);
 187                 aper->ranges[aper->count].size = pci_resource_len(pdev, 2);
 188                 aper->count++;
 189         }
 190
 191         if (pci_resource_len(pdev, 3)) {
 192                 aper->ranges[aper->count].base = pci_resource_start(pdev, 3);
 193                 aper->ranges[aper->count].size = pci_resource_len(pdev, 3);
 194                 aper->count++;
 195         }
 196
 197 #ifdef CONFIG_X86
 198         boot = pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW;
 199 #endif
 200         remove_conflicting_framebuffers(aper, "nouveaufb", boot);
 201
 202         ret = nouveau_device_create(pdev, nouveau_name(pdev), pci_name(pdev),
 203                                     nouveau_config, nouveau_debug, &device);
 204         if (ret)
 205                 return ret;
 206
 207         pci_set_master(pdev);
 208
 209         ret = nouveau_pci_probe(pdev, pent);
 210         if (ret) {
 211                 nouveau_object_ref(NULL, (struct nouveau_object **)&device);
 212                 return ret;
 213         }
 214
 215         return 0;
 216 }
 217
 218 int
 219 nouveau_drm_load(struct drm_device *dev, unsigned long flags)
 220 {
 221         struct pci_dev *pdev = dev->pdev;
 222         struct nouveau_device *device;
 223         struct nouveau_drm *drm;
 224         int ret;
 225
 226         ret = nouveau_cli_create(pdev, 0, sizeof(*drm), (void**)&drm);
 227         dev->dev_private = drm;
 228         if (ret)
 229                 return ret;
 230
 231         INIT_LIST_HEAD(&drm->clients);
 232         spin_lock_init(&drm->tile.lock);
 233         drm->dev = dev;
 234
 235         /* make sure AGP controller is in a consistent state before we
 236          * (possibly) execute vbios init tables (see nouveau_agp.h)
 237          */
 238         if (drm_pci_device_is_agp(dev) && dev->agp) {
 239                 /* dummy device object, doesn't init anything, but allows
 240                  * agp code access to registers
 241                  */
 242                 ret = nouveau_object_new(nv_object(drm), NVDRM_CLIENT,
 243                                          NVDRM_DEVICE, 0x0080,
 244                                          &(struct nv_device_class) {
 245                                                 .device = ~0,
 246                                                 .disable =
 247                                                  ~(NV_DEVICE_DISABLE_MMIO |
 248                                                    NV_DEVICE_DISABLE_IDENTIFY),
 249                                                 .debug0 = ~0,
 250                                          }, sizeof(struct nv_device_class),
 251                                          &drm->device);
 252                 if (ret)
 253                         goto fail_device;
 254
 255                 nouveau_agp_reset(drm);
 256                 nouveau_object_del(nv_object(drm), NVDRM_CLIENT, NVDRM_DEVICE);
 257         }
 258
 259         ret = nouveau_object_new(nv_object(drm), NVDRM_CLIENT, NVDRM_DEVICE,
 260                                  0x0080, &(struct nv_device_class) {
 261                                         .device = ~0,
 262                                         .disable = 0,
 263                                         .debug0 = 0,
 264                                  }, sizeof(struct nv_device_class),
 265                                  &drm->device);
 266         if (ret)
 267                 goto fail_device;
 268
 269         device = nv_device(drm->device);
 270
 271         /* initialise AGP */
 272         nouveau_agp_init(drm);
 273
 274         if (device->card_type >= NV_50) {
 275                 ret = nouveau_vm_new(nv_device(drm->device), 0, (1ULL << 40),
 276                                      0x1000, &drm->client.base.vm);
 277                 if (ret)
 278                         goto fail_device;
 279         }
 280
 281         ret = nouveau_ttm_init(drm);
 282         if (ret)
 283                 goto fail_device;
 284
 285         ret = nouveau_load(dev, flags);
 286         if (ret)
 287                 goto fail_load;
 288
 289         nouveau_accel_init(drm);
 290         nouveau_fbcon_init(dev);
 291         return 0;
 292
 293 fail_load:
 294         nouveau_ttm_fini(drm);
 295 fail_device:
 296         nouveau_cli_destroy(&drm->client);
 297         return ret;
 298 }
 299
 300 int
 301 nouveau_drm_unload(struct drm_device *dev)
 302 {
 303         struct nouveau_drm *drm = nouveau_newpriv(dev);
 304         struct pci_dev *pdev = dev->pdev;
 305         int ret;
 306
 307         nouveau_fbcon_fini(dev);
 308         nouveau_accel_fini(drm);
 309
 310         ret = nouveau_unload(dev);
 311         if (ret)
 312                 return ret;
 313
 314         nouveau_ttm_fini(drm);
 315         nouveau_agp_fini(drm);
 316
 317         pci_set_drvdata(pdev, drm->client.base.device);
 318         nouveau_cli_destroy(&drm->client);
 319         return 0;
 320 }
 321
 322 static void
 323 nouveau_drm_remove(struct pci_dev *pdev)
 324 {
 325         struct nouveau_object *device;
 326         nouveau_pci_remove(pdev);
 327         device = pci_get_drvdata(pdev);
 328         nouveau_object_ref(NULL, &device);
 329         nouveau_object_debug();
 330 }
 331
 332 int
 333 nouveau_drm_suspend(struct pci_dev *pdev, pm_message_t pm_state)
 334 {
 335         struct drm_device *dev = pci_get_drvdata(pdev);
 336         struct nouveau_drm *drm = nouveau_newpriv(dev);
 337         struct nouveau_cli *cli;
 338         int ret;
 339
 340         if (dev->switch_power_state == DRM_SWITCH_POWER_OFF ||
 341             pm_state.event == PM_EVENT_PRETHAW)
 342                 return 0;
 343
 344         NV_INFO(drm, "suspending fbcon...\n");
 345         nouveau_fbcon_set_suspend(dev, 1);
 346
 347         NV_INFO(drm, "suspending drm...\n");
 348         ret = nouveau_pci_suspend(pdev, pm_state);
 349         if (ret)
 350                 return ret;
 351
 352         NV_INFO(drm, "evicting buffers...\n");
 353         ttm_bo_evict_mm(&drm->ttm.bdev, TTM_PL_VRAM);
 354
 355         if (drm->fence && nouveau_fence(drm)->suspend) {
 356                 if (!nouveau_fence(drm)->suspend(drm))
 357                         return -ENOMEM;
 358         }
 359
 360         NV_INFO(drm, "suspending client object trees...\n");
 361         list_for_each_entry(cli, &drm->clients, head) {
 362                 ret = nouveau_client_fini(&cli->base, true);
 363                 if (ret)
 364                         goto fail_client;
 365         }
 366
 367         ret = nouveau_client_fini(&drm->client.base, true);
 368         if (ret)
 369                 goto fail_client;
 370
 371         nouveau_agp_fini(drm);
 372
 373         pci_save_state(pdev);
 374         if (pm_state.event == PM_EVENT_SUSPEND) {
 375                 pci_disable_device(pdev);
 376                 pci_set_power_state(pdev, PCI_D3hot);
 377         }
 378
 379         return 0;
 380
 381 fail_client:
 382         list_for_each_entry_continue_reverse(cli, &drm->clients, head) {
 383                 nouveau_client_init(&cli->base);
 384         }
 385
 386         nouveau_pci_resume(pdev);
 387         return ret;
 388 }
 389
 390 int
 391 nouveau_drm_resume(struct pci_dev *pdev)
 392 {
 393         struct drm_device *dev = pci_get_drvdata(pdev);
 394         struct nouveau_drm *drm = nouveau_newpriv(dev);
 395         struct nouveau_cli *cli;
 396         int ret;
 397
 398         if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
 399                 return 0;
 400
 401         NV_INFO(drm, "re-enabling device...\n");
 402         pci_set_power_state(pdev, PCI_D0);
 403         pci_restore_state(pdev);
 404         ret = pci_enable_device(pdev);
 405         if (ret)
 406                 return ret;
 407         pci_set_master(pdev);
 408
 409         nouveau_agp_reset(drm);
 410
 411         NV_INFO(drm, "resuming client object trees...\n");
 412         nouveau_client_init(&drm->client.base);
 413         nouveau_agp_init(drm);
 414
 415         list_for_each_entry(cli, &drm->clients, head) {
 416                 nouveau_client_init(&cli->base);
 417         }
 418
 419         if (drm->fence && nouveau_fence(drm)->resume)
 420                 nouveau_fence(drm)->resume(drm);
 421
 422         return nouveau_pci_resume(pdev);
 423 }
 424
 425 int
 426 nouveau_drm_open(struct drm_device *dev, struct drm_file *fpriv)
 427 {
 428         struct pci_dev *pdev = dev->pdev;
 429         struct nouveau_drm *drm = nouveau_drm(dev);
 430         struct nouveau_cli *cli;
 431         int ret;
 432
 433         ret = nouveau_cli_create(pdev, fpriv->pid, sizeof(*cli), (void **)&cli);
 434         if (ret)
 435                 return ret;
 436
 437         if (nv_device(drm->device)->card_type >= NV_50) {
 438                 ret = nouveau_vm_new(nv_device(drm->device), 0, (1ULL << 40),
 439                                      0x1000, &cli->base.vm);
 440                 if (ret) {
 441                         nouveau_cli_destroy(cli);
 442                         return ret;
 443                 }
 444         }
 445
 446         fpriv->driver_priv = cli;
 447
 448         mutex_lock(&drm->client.mutex);
 449         list_add(&cli->head, &drm->clients);
 450         mutex_unlock(&drm->client.mutex);
 451         return 0;
 452 }
 453
 454 void
 455 nouveau_drm_preclose(struct drm_device *dev, struct drm_file *fpriv)
 456 {
 457         struct nouveau_cli *cli = nouveau_cli(fpriv);
 458         struct nouveau_drm *drm = nouveau_drm(dev);
 459
 460         if (cli->abi16)
 461                 nouveau_abi16_fini(cli->abi16);
 462
 463         mutex_lock(&drm->client.mutex);
 464         list_del(&cli->head);
 465         mutex_unlock(&drm->client.mutex);
 466 }
 467
 468 void
 469 nouveau_drm_postclose(struct drm_device *dev, struct drm_file *fpriv)
 470 {
 471         struct nouveau_cli *cli = nouveau_cli(fpriv);
 472         nouveau_cli_destroy(cli);
 473 }
 474
 475 static struct pci_device_id
 476 nouveau_drm_pci_table[] = {
 477         {
 478                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
 479                 .class = PCI_BASE_CLASS_DISPLAY << 16,
 480                 .class_mask  = 0xff << 16,
 481         },
 482         {
 483                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA_SGS, PCI_ANY_ID),
 484                 .class = PCI_BASE_CLASS_DISPLAY << 16,
 485                 .class_mask  = 0xff << 16,
 486         },
 487         {}
 488 };
 489
 490 static struct pci_driver
 491 nouveau_drm_pci_driver = {
 492         .name = "nouveau",
 493         .id_table = nouveau_drm_pci_table,
 494         .probe = nouveau_drm_probe,
 495         .remove = nouveau_drm_remove,
 496         .suspend = nouveau_drm_suspend,
 497         .resume = nouveau_drm_resume,
 498 };
 499
 500 static int __init
 501 nouveau_drm_init(void)
 502 {
 503         return nouveau_init(&nouveau_drm_pci_driver);
 504 }
 505
 506 static void __exit
 507 nouveau_drm_exit(void)
 508 {
 509         nouveau_exit(&nouveau_drm_pci_driver);
 510 }
 511
 512 module_init(nouveau_drm_init);
 513 module_exit(nouveau_drm_exit);
 514
 515 MODULE_DEVICE_TABLE(pci, nouveau_drm_pci_table);
 516 MODULE_AUTHOR("Nouveau Project");
 517 MODULE_DESCRIPTION("nVidia Riva/TNT/GeForce/Quadro/Tesla");
 518 MODULE_LICENSE("GPL and additional rights");