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/console.h> 26#include <linux/module.h> 27#include <linux/pci.h> 28#include <linux/pm_runtime.h> 29#include <linux/vga_switcheroo.h> 30 31#include "drmP.h" 32#include "drm_crtc_helper.h" 33 34#include <core/device.h> 35#include <core/gpuobj.h> 36#include <core/option.h> 37 38#include "nouveau_drm.h" 39#include "nouveau_dma.h" 40#include "nouveau_ttm.h" 41#include "nouveau_gem.h" 42#include "nouveau_agp.h" 43#include "nouveau_vga.h" 44#include "nouveau_sysfs.h" 45#include "nouveau_hwmon.h" 46#include "nouveau_acpi.h" 47#include "nouveau_bios.h" 48#include "nouveau_ioctl.h" 49#include "nouveau_abi16.h" 50#include "nouveau_fbcon.h" 51#include "nouveau_fence.h" 52#include "nouveau_debugfs.h" 53#include "nouveau_usif.h" 54#include "nouveau_connector.h" 55#include "nouveau_platform.h" 56 57MODULE_PARM_DESC(config, "option string to pass to driver core"); 58static char *nouveau_config; 59module_param_named(config, nouveau_config, charp, 0400); 60 61MODULE_PARM_DESC(debug, "debug string to pass to driver core"); 62static char *nouveau_debug; 63module_param_named(debug, nouveau_debug, charp, 0400); 64 65MODULE_PARM_DESC(noaccel, "disable kernel/abi16 acceleration"); 66static int nouveau_noaccel = 0; 67module_param_named(noaccel, nouveau_noaccel, int, 0400); 68 69MODULE_PARM_DESC(modeset, "enable driver (default: auto, " 70 "0 = disabled, 1 = enabled, 2 = headless)"); 71int nouveau_modeset = -1; 72module_param_named(modeset, nouveau_modeset, int, 0400); 73 74MODULE_PARM_DESC(runpm, "disable (0), force enable (1), optimus only default (-1)"); 75int nouveau_runtime_pm = -1; 76module_param_named(runpm, nouveau_runtime_pm, int, 0400); 77 78static struct drm_driver driver_stub; 79static struct drm_driver driver_pci; 80static struct drm_driver driver_platform; 81 82static u64 83nouveau_pci_name(struct pci_dev *pdev) 84{ 85 u64 name = (u64)pci_domain_nr(pdev->bus) << 32; 86 name |= pdev->bus->number << 16; 87 name |= PCI_SLOT(pdev->devfn) << 8; 88 return name | PCI_FUNC(pdev->devfn); 89} 90 91static u64 92nouveau_platform_name(struct platform_device *platformdev) 93{ 94 return platformdev->id; 95} 96 97static u64 98nouveau_name(struct drm_device *dev) 99{ 100 if (dev->pdev) 101 return nouveau_pci_name(dev->pdev); 102 else 103 return nouveau_platform_name(dev->platformdev); 104} 105 106static int 107nouveau_cli_create(u64 name, const char *sname, 108 int size, void **pcli) 109{ 110 struct nouveau_cli *cli = *pcli = kzalloc(size, GFP_KERNEL); 111 if (cli) { 112 int ret = nvif_client_init(NULL, NULL, sname, name, 113 nouveau_config, nouveau_debug, 114 &cli->base); 115 if (ret == 0) { 116 mutex_init(&cli->mutex); 117 usif_client_init(cli); 118 } 119 return ret; 120 } 121 return -ENOMEM; 122} 123 124static void 125nouveau_cli_destroy(struct nouveau_cli *cli) 126{ 127 nvkm_vm_ref(NULL, &nvxx_client(&cli->base)->vm, NULL); 128 nvif_client_fini(&cli->base); 129 usif_client_fini(cli); 130} 131 132static void 133nouveau_accel_fini(struct nouveau_drm *drm) 134{ 135 nouveau_channel_del(&drm->channel); 136 nvif_object_fini(&drm->ntfy); 137 nvkm_gpuobj_ref(NULL, &drm->notify); 138 nvif_object_fini(&drm->nvsw); 139 nouveau_channel_del(&drm->cechan); 140 nvif_object_fini(&drm->ttm.copy); 141 if (drm->fence) 142 nouveau_fence(drm)->dtor(drm); 143} 144 145static void 146nouveau_accel_init(struct nouveau_drm *drm) 147{ 148 struct nvif_device *device = &drm->device; 149 u32 arg0, arg1; 150 u32 sclass[16]; 151 int ret, i; 152 153 if (nouveau_noaccel) 154 return; 155 156 /* initialise synchronisation routines */ 157 /*XXX: this is crap, but the fence/channel stuff is a little 158 * backwards in some places. this will be fixed. 159 */ 160 ret = nvif_object_sclass(&device->base, sclass, ARRAY_SIZE(sclass)); 161 if (ret < 0) 162 return; 163 164 for (ret = -ENOSYS, i = 0; ret && i < ARRAY_SIZE(sclass); i++) { 165 switch (sclass[i]) { 166 case NV03_CHANNEL_DMA: 167 ret = nv04_fence_create(drm); 168 break; 169 case NV10_CHANNEL_DMA: 170 ret = nv10_fence_create(drm); 171 break; 172 case NV17_CHANNEL_DMA: 173 case NV40_CHANNEL_DMA: 174 ret = nv17_fence_create(drm); 175 break; 176 case NV50_CHANNEL_GPFIFO: 177 ret = nv50_fence_create(drm); 178 break; 179 case G82_CHANNEL_GPFIFO: 180 ret = nv84_fence_create(drm); 181 break; 182 case FERMI_CHANNEL_GPFIFO: 183 case KEPLER_CHANNEL_GPFIFO_A: 184 case MAXWELL_CHANNEL_GPFIFO_A: 185 ret = nvc0_fence_create(drm); 186 break; 187 default: 188 break; 189 } 190 } 191 192 if (ret) { 193 NV_ERROR(drm, "failed to initialise sync subsystem, %d\n", ret); 194 nouveau_accel_fini(drm); 195 return; 196 } 197 198 if (device->info.family >= NV_DEVICE_INFO_V0_KEPLER) { 199 ret = nouveau_channel_new(drm, &drm->device, NVDRM_CHAN + 1, 200 KEPLER_CHANNEL_GPFIFO_A_V0_ENGINE_CE0| 201 KEPLER_CHANNEL_GPFIFO_A_V0_ENGINE_CE1, 202 0, &drm->cechan); 203 if (ret) 204 NV_ERROR(drm, "failed to create ce channel, %d\n", ret); 205 206 arg0 = KEPLER_CHANNEL_GPFIFO_A_V0_ENGINE_GR; 207 arg1 = 1; 208 } else 209 if (device->info.chipset >= 0xa3 && 210 device->info.chipset != 0xaa && 211 device->info.chipset != 0xac) { 212 ret = nouveau_channel_new(drm, &drm->device, NVDRM_CHAN + 1, 213 NvDmaFB, NvDmaTT, &drm->cechan); 214 if (ret) 215 NV_ERROR(drm, "failed to create ce channel, %d\n", ret); 216 217 arg0 = NvDmaFB; 218 arg1 = NvDmaTT; 219 } else { 220 arg0 = NvDmaFB; 221 arg1 = NvDmaTT; 222 } 223 224 ret = nouveau_channel_new(drm, &drm->device, NVDRM_CHAN, arg0, arg1, 225 &drm->channel); 226 if (ret) { 227 NV_ERROR(drm, "failed to create kernel channel, %d\n", ret); 228 nouveau_accel_fini(drm); 229 return; 230 } 231 232 ret = nvif_object_init(drm->channel->object, NULL, NVDRM_NVSW, 233 nouveau_abi16_swclass(drm), NULL, 0, &drm->nvsw); 234 if (ret == 0) { 235 struct nvkm_sw_chan *swch; 236 ret = RING_SPACE(drm->channel, 2); 237 if (ret == 0) { 238 if (device->info.family < NV_DEVICE_INFO_V0_FERMI) { 239 BEGIN_NV04(drm->channel, NvSubSw, 0, 1); 240 OUT_RING (drm->channel, NVDRM_NVSW); 241 } else 242 if (device->info.family < NV_DEVICE_INFO_V0_KEPLER) { 243 BEGIN_NVC0(drm->channel, FermiSw, 0, 1); 244 OUT_RING (drm->channel, 0x001f0000); 245 } 246 } 247 swch = (void *)nvxx_object(&drm->nvsw)->parent; 248 swch->flip = nouveau_flip_complete; 249 swch->flip_data = drm->channel; 250 } 251 252 if (ret) { 253 NV_ERROR(drm, "failed to allocate software object, %d\n", ret); 254 nouveau_accel_fini(drm); 255 return; 256 } 257 258 if (device->info.family < NV_DEVICE_INFO_V0_FERMI) { 259 ret = nvkm_gpuobj_new(nvxx_object(&drm->device), NULL, 32, 260 0, 0, &drm->notify); 261 if (ret) { 262 NV_ERROR(drm, "failed to allocate notifier, %d\n", ret); 263 nouveau_accel_fini(drm); 264 return; 265 } 266 267 ret = nvif_object_init(drm->channel->object, NULL, NvNotify0, 268 NV_DMA_IN_MEMORY, 269 &(struct nv_dma_v0) { 270 .target = NV_DMA_V0_TARGET_VRAM, 271 .access = NV_DMA_V0_ACCESS_RDWR, 272 .start = drm->notify->addr, 273 .limit = drm->notify->addr + 31 274 }, sizeof(struct nv_dma_v0), 275 &drm->ntfy); 276 if (ret) { 277 nouveau_accel_fini(drm); 278 return; 279 } 280 } 281 282 283 nouveau_bo_move_init(drm); 284} 285 286static int nouveau_drm_probe(struct pci_dev *pdev, 287 const struct pci_device_id *pent) 288{ 289 struct nvkm_device *device; 290 struct apertures_struct *aper; 291 bool boot = false; 292 int ret; 293 294 /* remove conflicting drivers (vesafb, efifb etc) */ 295 aper = alloc_apertures(3); 296 if (!aper) 297 return -ENOMEM; 298 299 aper->ranges[0].base = pci_resource_start(pdev, 1); 300 aper->ranges[0].size = pci_resource_len(pdev, 1); 301 aper->count = 1; 302 303 if (pci_resource_len(pdev, 2)) { 304 aper->ranges[aper->count].base = pci_resource_start(pdev, 2); 305 aper->ranges[aper->count].size = pci_resource_len(pdev, 2); 306 aper->count++; 307 } 308 309 if (pci_resource_len(pdev, 3)) { 310 aper->ranges[aper->count].base = pci_resource_start(pdev, 3); 311 aper->ranges[aper->count].size = pci_resource_len(pdev, 3); 312 aper->count++; 313 } 314 315#ifdef CONFIG_X86 316 boot = pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW; 317#endif 318 if (nouveau_modeset != 2) 319 remove_conflicting_framebuffers(aper, "nouveaufb", boot); 320 kfree(aper); 321 322 ret = nvkm_device_create(pdev, NVKM_BUS_PCI, 323 nouveau_pci_name(pdev), pci_name(pdev), 324 nouveau_config, nouveau_debug, &device); 325 if (ret) 326 return ret; 327 328 pci_set_master(pdev); 329 330 ret = drm_get_pci_dev(pdev, pent, &driver_pci); 331 if (ret) { 332 nvkm_object_ref(NULL, (struct nvkm_object **)&device); 333 return ret; 334 } 335 336 return 0; 337} 338 339#define PCI_CLASS_MULTIMEDIA_HD_AUDIO 0x0403 340 341static void 342nouveau_get_hdmi_dev(struct nouveau_drm *drm) 343{ 344 struct pci_dev *pdev = drm->dev->pdev; 345 346 if (!pdev) { 347 DRM_INFO("not a PCI device; no HDMI\n"); 348 drm->hdmi_device = NULL; 349 return; 350 } 351 352 /* subfunction one is a hdmi audio device? */ 353 drm->hdmi_device = pci_get_bus_and_slot((unsigned int)pdev->bus->number, 354 PCI_DEVFN(PCI_SLOT(pdev->devfn), 1)); 355 356 if (!drm->hdmi_device) { 357 NV_DEBUG(drm, "hdmi device not found %d %d %d\n", pdev->bus->number, PCI_SLOT(pdev->devfn), 1); 358 return; 359 } 360 361 if ((drm->hdmi_device->class >> 8) != PCI_CLASS_MULTIMEDIA_HD_AUDIO) { 362 NV_DEBUG(drm, "possible hdmi device not audio %d\n", drm->hdmi_device->class); 363 pci_dev_put(drm->hdmi_device); 364 drm->hdmi_device = NULL; 365 return; 366 } 367} 368 369static int 370nouveau_drm_load(struct drm_device *dev, unsigned long flags) 371{ 372 struct pci_dev *pdev = dev->pdev; 373 struct nouveau_drm *drm; 374 int ret; 375 376 ret = nouveau_cli_create(nouveau_name(dev), "DRM", sizeof(*drm), 377 (void **)&drm); 378 if (ret) 379 return ret; 380 381 dev->dev_private = drm; 382 drm->dev = dev; 383 nvxx_client(&drm->client.base)->debug = 384 nvkm_dbgopt(nouveau_debug, "DRM"); 385 386 INIT_LIST_HEAD(&drm->clients); 387 spin_lock_init(&drm->tile.lock); 388 389 nouveau_get_hdmi_dev(drm); 390 391 /* make sure AGP controller is in a consistent state before we 392 * (possibly) execute vbios init tables (see nouveau_agp.h) 393 */ 394 if (pdev && drm_pci_device_is_agp(dev) && dev->agp) { 395 const u64 enables = NV_DEVICE_V0_DISABLE_IDENTIFY | 396 NV_DEVICE_V0_DISABLE_MMIO; 397 /* dummy device object, doesn't init anything, but allows 398 * agp code access to registers 399 */ 400 ret = nvif_device_init(&drm->client.base.base, NULL, 401 NVDRM_DEVICE, NV_DEVICE, 402 &(struct nv_device_v0) { 403 .device = ~0, 404 .disable = ~enables, 405 .debug0 = ~0, 406 }, sizeof(struct nv_device_v0), 407 &drm->device); 408 if (ret) 409 goto fail_device; 410 411 nouveau_agp_reset(drm); 412 nvif_device_fini(&drm->device); 413 } 414 415 ret = nvif_device_init(&drm->client.base.base, NULL, NVDRM_DEVICE, 416 NV_DEVICE, 417 &(struct nv_device_v0) { 418 .device = ~0, 419 .disable = 0, 420 .debug0 = 0, 421 }, sizeof(struct nv_device_v0), 422 &drm->device); 423 if (ret) 424 goto fail_device; 425 426 dev->irq_enabled = true; 427 428 /* workaround an odd issue on nvc1 by disabling the device's 429 * nosnoop capability. hopefully won't cause issues until a 430 * better fix is found - assuming there is one... 431 */ 432 if (drm->device.info.chipset == 0xc1) 433 nvif_mask(&drm->device, 0x00088080, 0x00000800, 0x00000000); 434 435 nouveau_vga_init(drm); 436 nouveau_agp_init(drm); 437 438 if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) { 439 ret = nvkm_vm_new(nvxx_device(&drm->device), 0, (1ULL << 40), 440 0x1000, &drm->client.vm); 441 if (ret) 442 goto fail_device; 443 444 nvxx_client(&drm->client.base)->vm = drm->client.vm; 445 } 446 447 ret = nouveau_ttm_init(drm); 448 if (ret) 449 goto fail_ttm; 450 451 ret = nouveau_bios_init(dev); 452 if (ret) 453 goto fail_bios; 454 455 ret = nouveau_display_create(dev); 456 if (ret) 457 goto fail_dispctor; 458 459 if (dev->mode_config.num_crtc) { 460 ret = nouveau_display_init(dev); 461 if (ret) 462 goto fail_dispinit; 463 } 464 465 nouveau_sysfs_init(dev); 466 nouveau_hwmon_init(dev); 467 nouveau_accel_init(drm); 468 nouveau_fbcon_init(dev); 469 470 if (nouveau_runtime_pm != 0) { 471 pm_runtime_use_autosuspend(dev->dev); 472 pm_runtime_set_autosuspend_delay(dev->dev, 5000); 473 pm_runtime_set_active(dev->dev); 474 pm_runtime_allow(dev->dev); 475 pm_runtime_mark_last_busy(dev->dev); 476 pm_runtime_put(dev->dev); 477 } 478 return 0; 479 480fail_dispinit: 481 nouveau_display_destroy(dev); 482fail_dispctor: 483 nouveau_bios_takedown(dev); 484fail_bios: 485 nouveau_ttm_fini(drm); 486fail_ttm: 487 nouveau_agp_fini(drm); 488 nouveau_vga_fini(drm); 489fail_device: 490 nvif_device_fini(&drm->device); 491 nouveau_cli_destroy(&drm->client); 492 return ret; 493} 494 495static int 496nouveau_drm_unload(struct drm_device *dev) 497{ 498 struct nouveau_drm *drm = nouveau_drm(dev); 499 500 pm_runtime_get_sync(dev->dev); 501 nouveau_fbcon_fini(dev); 502 nouveau_accel_fini(drm); 503 nouveau_hwmon_fini(dev); 504 nouveau_sysfs_fini(dev); 505 506 if (dev->mode_config.num_crtc) 507 nouveau_display_fini(dev); 508 nouveau_display_destroy(dev); 509 510 nouveau_bios_takedown(dev); 511 512 nouveau_ttm_fini(drm); 513 nouveau_agp_fini(drm); 514 nouveau_vga_fini(drm); 515 516 nvif_device_fini(&drm->device); 517 if (drm->hdmi_device) 518 pci_dev_put(drm->hdmi_device); 519 nouveau_cli_destroy(&drm->client); 520 return 0; 521} 522 523void 524nouveau_drm_device_remove(struct drm_device *dev) 525{ 526 struct nouveau_drm *drm = nouveau_drm(dev); 527 struct nvkm_client *client; 528 struct nvkm_object *device; 529 530 dev->irq_enabled = false; 531 client = nvxx_client(&drm->client.base); 532 device = client->device; 533 drm_put_dev(dev); 534 535 nvkm_object_ref(NULL, &device); 536 nvkm_object_debug(); 537} 538 539static void 540nouveau_drm_remove(struct pci_dev *pdev) 541{ 542 struct drm_device *dev = pci_get_drvdata(pdev); 543 544 nouveau_drm_device_remove(dev); 545} 546 547static int 548nouveau_do_suspend(struct drm_device *dev, bool runtime) 549{ 550 struct nouveau_drm *drm = nouveau_drm(dev); 551 struct nouveau_cli *cli; 552 int ret; 553 554 if (dev->mode_config.num_crtc) { 555 NV_INFO(drm, "suspending console...\n"); 556 nouveau_fbcon_set_suspend(dev, 1); 557 NV_INFO(drm, "suspending display...\n"); 558 ret = nouveau_display_suspend(dev, runtime); 559 if (ret) 560 return ret; 561 } 562 563 NV_INFO(drm, "evicting buffers...\n"); 564 ttm_bo_evict_mm(&drm->ttm.bdev, TTM_PL_VRAM); 565 566 NV_INFO(drm, "waiting for kernel channels to go idle...\n"); 567 if (drm->cechan) { 568 ret = nouveau_channel_idle(drm->cechan); 569 if (ret) 570 goto fail_display; 571 } 572 573 if (drm->channel) { 574 ret = nouveau_channel_idle(drm->channel); 575 if (ret) 576 goto fail_display; 577 } 578 579 NV_INFO(drm, "suspending client object trees...\n"); 580 if (drm->fence && nouveau_fence(drm)->suspend) { 581 if (!nouveau_fence(drm)->suspend(drm)) { 582 ret = -ENOMEM; 583 goto fail_display; 584 } 585 } 586 587 list_for_each_entry(cli, &drm->clients, head) { 588 ret = nvif_client_suspend(&cli->base); 589 if (ret) 590 goto fail_client; 591 } 592 593 NV_INFO(drm, "suspending kernel object tree...\n"); 594 ret = nvif_client_suspend(&drm->client.base); 595 if (ret) 596 goto fail_client; 597 598 nouveau_agp_fini(drm); 599 return 0; 600 601fail_client: 602 list_for_each_entry_continue_reverse(cli, &drm->clients, head) { 603 nvif_client_resume(&cli->base); 604 } 605 606 if (drm->fence && nouveau_fence(drm)->resume) 607 nouveau_fence(drm)->resume(drm); 608 609fail_display: 610 if (dev->mode_config.num_crtc) { 611 NV_INFO(drm, "resuming display...\n"); 612 nouveau_display_resume(dev, runtime); 613 } 614 return ret; 615} 616 617static int 618nouveau_do_resume(struct drm_device *dev, bool runtime) 619{ 620 struct nouveau_drm *drm = nouveau_drm(dev); 621 struct nouveau_cli *cli; 622 623 NV_INFO(drm, "re-enabling device...\n"); 624 625 nouveau_agp_reset(drm); 626 627 NV_INFO(drm, "resuming kernel object tree...\n"); 628 nvif_client_resume(&drm->client.base); 629 nouveau_agp_init(drm); 630 631 NV_INFO(drm, "resuming client object trees...\n"); 632 if (drm->fence && nouveau_fence(drm)->resume) 633 nouveau_fence(drm)->resume(drm); 634 635 list_for_each_entry(cli, &drm->clients, head) { 636 nvif_client_resume(&cli->base); 637 } 638 639 nouveau_run_vbios_init(dev); 640 641 if (dev->mode_config.num_crtc) { 642 NV_INFO(drm, "resuming display...\n"); 643 nouveau_display_resume(dev, runtime); 644 NV_INFO(drm, "resuming console...\n"); 645 nouveau_fbcon_set_suspend(dev, 0); 646 } 647 648 return 0; 649} 650 651int 652nouveau_pmops_suspend(struct device *dev) 653{ 654 struct pci_dev *pdev = to_pci_dev(dev); 655 struct drm_device *drm_dev = pci_get_drvdata(pdev); 656 int ret; 657 658 if (drm_dev->switch_power_state == DRM_SWITCH_POWER_OFF || 659 drm_dev->switch_power_state == DRM_SWITCH_POWER_DYNAMIC_OFF) 660 return 0; 661 662 ret = nouveau_do_suspend(drm_dev, false); 663 if (ret) 664 return ret; 665 666 pci_save_state(pdev); 667 pci_disable_device(pdev); 668 pci_set_power_state(pdev, PCI_D3hot); 669 return 0; 670} 671 672int 673nouveau_pmops_resume(struct device *dev) 674{ 675 struct pci_dev *pdev = to_pci_dev(dev); 676 struct drm_device *drm_dev = pci_get_drvdata(pdev); 677 int ret; 678 679 if (drm_dev->switch_power_state == DRM_SWITCH_POWER_OFF || 680 drm_dev->switch_power_state == DRM_SWITCH_POWER_DYNAMIC_OFF) 681 return 0; 682 683 pci_set_power_state(pdev, PCI_D0); 684 pci_restore_state(pdev); 685 ret = pci_enable_device(pdev); 686 if (ret) 687 return ret; 688 pci_set_master(pdev); 689 690 return nouveau_do_resume(drm_dev, false); 691} 692 693static int 694nouveau_pmops_freeze(struct device *dev) 695{ 696 struct pci_dev *pdev = to_pci_dev(dev); 697 struct drm_device *drm_dev = pci_get_drvdata(pdev); 698 return nouveau_do_suspend(drm_dev, false); 699} 700 701static int 702nouveau_pmops_thaw(struct device *dev) 703{ 704 struct pci_dev *pdev = to_pci_dev(dev); 705 struct drm_device *drm_dev = pci_get_drvdata(pdev); 706 return nouveau_do_resume(drm_dev, false); 707} 708 709static int 710nouveau_pmops_runtime_suspend(struct device *dev) 711{ 712 struct pci_dev *pdev = to_pci_dev(dev); 713 struct drm_device *drm_dev = pci_get_drvdata(pdev); 714 int ret; 715 716 if (nouveau_runtime_pm == 0) { 717 pm_runtime_forbid(dev); 718 return -EBUSY; 719 } 720 721 /* are we optimus enabled? */ 722 if (nouveau_runtime_pm == -1 && !nouveau_is_optimus() && !nouveau_is_v1_dsm()) { 723 DRM_DEBUG_DRIVER("failing to power off - not optimus\n"); 724 pm_runtime_forbid(dev); 725 return -EBUSY; 726 } 727 728 nv_debug_level(SILENT); 729 drm_kms_helper_poll_disable(drm_dev); 730 vga_switcheroo_set_dynamic_switch(pdev, VGA_SWITCHEROO_OFF); 731 nouveau_switcheroo_optimus_dsm(); 732 ret = nouveau_do_suspend(drm_dev, true); 733 pci_save_state(pdev); 734 pci_disable_device(pdev); 735 pci_ignore_hotplug(pdev); 736 pci_set_power_state(pdev, PCI_D3cold); 737 drm_dev->switch_power_state = DRM_SWITCH_POWER_DYNAMIC_OFF; 738 return ret; 739} 740 741static int 742nouveau_pmops_runtime_resume(struct device *dev) 743{ 744 struct pci_dev *pdev = to_pci_dev(dev); 745 struct drm_device *drm_dev = pci_get_drvdata(pdev); 746 struct nvif_device *device = &nouveau_drm(drm_dev)->device; 747 int ret; 748 749 if (nouveau_runtime_pm == 0) 750 return -EINVAL; 751 752 pci_set_power_state(pdev, PCI_D0); 753 pci_restore_state(pdev); 754 ret = pci_enable_device(pdev); 755 if (ret) 756 return ret; 757 pci_set_master(pdev); 758 759 ret = nouveau_do_resume(drm_dev, true); 760 drm_kms_helper_poll_enable(drm_dev); 761 /* do magic */ 762 nvif_mask(device, 0x88488, (1 << 25), (1 << 25)); 763 vga_switcheroo_set_dynamic_switch(pdev, VGA_SWITCHEROO_ON); 764 drm_dev->switch_power_state = DRM_SWITCH_POWER_ON; 765 nv_debug_level(NORMAL); 766 return ret; 767} 768 769static int 770nouveau_pmops_runtime_idle(struct device *dev) 771{ 772 struct pci_dev *pdev = to_pci_dev(dev); 773 struct drm_device *drm_dev = pci_get_drvdata(pdev); 774 struct nouveau_drm *drm = nouveau_drm(drm_dev); 775 struct drm_crtc *crtc; 776 777 if (nouveau_runtime_pm == 0) { 778 pm_runtime_forbid(dev); 779 return -EBUSY; 780 } 781 782 /* are we optimus enabled? */ 783 if (nouveau_runtime_pm == -1 && !nouveau_is_optimus() && !nouveau_is_v1_dsm()) { 784 DRM_DEBUG_DRIVER("failing to power off - not optimus\n"); 785 pm_runtime_forbid(dev); 786 return -EBUSY; 787 } 788 789 /* if we have a hdmi audio device - make sure it has a driver loaded */ 790 if (drm->hdmi_device) { 791 if (!drm->hdmi_device->driver) { 792 DRM_DEBUG_DRIVER("failing to power off - no HDMI audio driver loaded\n"); 793 pm_runtime_mark_last_busy(dev); 794 return -EBUSY; 795 } 796 } 797 798 list_for_each_entry(crtc, &drm->dev->mode_config.crtc_list, head) { 799 if (crtc->enabled) { 800 DRM_DEBUG_DRIVER("failing to power off - crtc active\n"); 801 return -EBUSY; 802 } 803 } 804 pm_runtime_mark_last_busy(dev); 805 pm_runtime_autosuspend(dev); 806 /* we don't want the main rpm_idle to call suspend - we want to autosuspend */ 807 return 1; 808} 809 810static int 811nouveau_drm_open(struct drm_device *dev, struct drm_file *fpriv) 812{ 813 struct nouveau_drm *drm = nouveau_drm(dev); 814 struct nouveau_cli *cli; 815 char name[32], tmpname[TASK_COMM_LEN]; 816 int ret; 817 818 /* need to bring up power immediately if opening device */ 819 ret = pm_runtime_get_sync(dev->dev); 820 if (ret < 0 && ret != -EACCES) 821 return ret; 822 823 get_task_comm(tmpname, current); 824 snprintf(name, sizeof(name), "%s[%d]", tmpname, pid_nr(fpriv->pid)); 825 826 ret = nouveau_cli_create(nouveau_name(dev), name, sizeof(*cli), 827 (void **)&cli); 828 829 if (ret) 830 goto out_suspend; 831 832 cli->base.super = false; 833 834 if (drm->device.info.family >= NV_DEVICE_INFO_V0_TESLA) { 835 ret = nvkm_vm_new(nvxx_device(&drm->device), 0, (1ULL << 40), 836 0x1000, &cli->vm); 837 if (ret) { 838 nouveau_cli_destroy(cli); 839 goto out_suspend; 840 } 841 842 nvxx_client(&cli->base)->vm = cli->vm; 843 } 844 845 fpriv->driver_priv = cli; 846 847 mutex_lock(&drm->client.mutex); 848 list_add(&cli->head, &drm->clients); 849 mutex_unlock(&drm->client.mutex); 850 851out_suspend: 852 pm_runtime_mark_last_busy(dev->dev); 853 pm_runtime_put_autosuspend(dev->dev); 854 855 return ret; 856} 857 858static void 859nouveau_drm_preclose(struct drm_device *dev, struct drm_file *fpriv) 860{ 861 struct nouveau_cli *cli = nouveau_cli(fpriv); 862 struct nouveau_drm *drm = nouveau_drm(dev); 863 864 pm_runtime_get_sync(dev->dev); 865 866 mutex_lock(&cli->mutex); 867 if (cli->abi16) 868 nouveau_abi16_fini(cli->abi16); 869 mutex_unlock(&cli->mutex); 870 871 mutex_lock(&drm->client.mutex); 872 list_del(&cli->head); 873 mutex_unlock(&drm->client.mutex); 874 875} 876 877static void 878nouveau_drm_postclose(struct drm_device *dev, struct drm_file *fpriv) 879{ 880 struct nouveau_cli *cli = nouveau_cli(fpriv); 881 nouveau_cli_destroy(cli); 882 pm_runtime_mark_last_busy(dev->dev); 883 pm_runtime_put_autosuspend(dev->dev); 884} 885 886static const struct drm_ioctl_desc 887nouveau_ioctls[] = { 888 DRM_IOCTL_DEF_DRV(NOUVEAU_GETPARAM, nouveau_abi16_ioctl_getparam, DRM_UNLOCKED|DRM_AUTH|DRM_RENDER_ALLOW), 889 DRM_IOCTL_DEF_DRV(NOUVEAU_SETPARAM, nouveau_abi16_ioctl_setparam, DRM_UNLOCKED|DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 890 DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_ALLOC, nouveau_abi16_ioctl_channel_alloc, DRM_UNLOCKED|DRM_AUTH|DRM_RENDER_ALLOW), 891 DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_FREE, nouveau_abi16_ioctl_channel_free, DRM_UNLOCKED|DRM_AUTH|DRM_RENDER_ALLOW), 892 DRM_IOCTL_DEF_DRV(NOUVEAU_GROBJ_ALLOC, nouveau_abi16_ioctl_grobj_alloc, DRM_UNLOCKED|DRM_AUTH|DRM_RENDER_ALLOW), 893 DRM_IOCTL_DEF_DRV(NOUVEAU_NOTIFIEROBJ_ALLOC, nouveau_abi16_ioctl_notifierobj_alloc, DRM_UNLOCKED|DRM_AUTH|DRM_RENDER_ALLOW), 894 DRM_IOCTL_DEF_DRV(NOUVEAU_GPUOBJ_FREE, nouveau_abi16_ioctl_gpuobj_free, DRM_UNLOCKED|DRM_AUTH|DRM_RENDER_ALLOW), 895 DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_NEW, nouveau_gem_ioctl_new, DRM_UNLOCKED|DRM_AUTH|DRM_RENDER_ALLOW), 896 DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_PUSHBUF, nouveau_gem_ioctl_pushbuf, DRM_UNLOCKED|DRM_AUTH|DRM_RENDER_ALLOW), 897 DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_PREP, nouveau_gem_ioctl_cpu_prep, DRM_UNLOCKED|DRM_AUTH|DRM_RENDER_ALLOW), 898 DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_FINI, nouveau_gem_ioctl_cpu_fini, DRM_UNLOCKED|DRM_AUTH|DRM_RENDER_ALLOW), 899 DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_INFO, nouveau_gem_ioctl_info, DRM_UNLOCKED|DRM_AUTH|DRM_RENDER_ALLOW), 900}; 901 902long 903nouveau_drm_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 904{ 905 struct drm_file *filp = file->private_data; 906 struct drm_device *dev = filp->minor->dev; 907 long ret; 908 909 ret = pm_runtime_get_sync(dev->dev); 910 if (ret < 0 && ret != -EACCES) 911 return ret; 912 913 switch (_IOC_NR(cmd) - DRM_COMMAND_BASE) { 914 case DRM_NOUVEAU_NVIF: 915 ret = usif_ioctl(filp, (void __user *)arg, _IOC_SIZE(cmd)); 916 break; 917 default: 918 ret = drm_ioctl(file, cmd, arg); 919 break; 920 } 921 922 pm_runtime_mark_last_busy(dev->dev); 923 pm_runtime_put_autosuspend(dev->dev); 924 return ret; 925} 926 927static const struct file_operations 928nouveau_driver_fops = { 929 .owner = THIS_MODULE, 930 .open = drm_open, 931 .release = drm_release, 932 .unlocked_ioctl = nouveau_drm_ioctl, 933 .mmap = nouveau_ttm_mmap, 934 .poll = drm_poll, 935 .read = drm_read, 936#if defined(CONFIG_COMPAT) 937 .compat_ioctl = nouveau_compat_ioctl, 938#endif 939 .llseek = noop_llseek, 940}; 941 942static struct drm_driver 943driver_stub = { 944 .driver_features = 945 DRIVER_USE_AGP | 946 DRIVER_GEM | DRIVER_MODESET | DRIVER_PRIME | DRIVER_RENDER, 947 948 .load = nouveau_drm_load, 949 .unload = nouveau_drm_unload, 950 .open = nouveau_drm_open, 951 .preclose = nouveau_drm_preclose, 952 .postclose = nouveau_drm_postclose, 953 .lastclose = nouveau_vga_lastclose, 954 955#if defined(CONFIG_DEBUG_FS) 956 .debugfs_init = nouveau_debugfs_init, 957 .debugfs_cleanup = nouveau_debugfs_takedown, 958#endif 959 960 .get_vblank_counter = drm_vblank_count, 961 .enable_vblank = nouveau_display_vblank_enable, 962 .disable_vblank = nouveau_display_vblank_disable, 963 .get_scanout_position = nouveau_display_scanoutpos, 964 .get_vblank_timestamp = nouveau_display_vblstamp, 965 966 .ioctls = nouveau_ioctls, 967 .num_ioctls = ARRAY_SIZE(nouveau_ioctls), 968 .fops = &nouveau_driver_fops, 969 970 .prime_handle_to_fd = drm_gem_prime_handle_to_fd, 971 .prime_fd_to_handle = drm_gem_prime_fd_to_handle, 972 .gem_prime_export = drm_gem_prime_export, 973 .gem_prime_import = drm_gem_prime_import, 974 .gem_prime_pin = nouveau_gem_prime_pin, 975 .gem_prime_res_obj = nouveau_gem_prime_res_obj, 976 .gem_prime_unpin = nouveau_gem_prime_unpin, 977 .gem_prime_get_sg_table = nouveau_gem_prime_get_sg_table, 978 .gem_prime_import_sg_table = nouveau_gem_prime_import_sg_table, 979 .gem_prime_vmap = nouveau_gem_prime_vmap, 980 .gem_prime_vunmap = nouveau_gem_prime_vunmap, 981 982 .gem_free_object = nouveau_gem_object_del, 983 .gem_open_object = nouveau_gem_object_open, 984 .gem_close_object = nouveau_gem_object_close, 985 986 .dumb_create = nouveau_display_dumb_create, 987 .dumb_map_offset = nouveau_display_dumb_map_offset, 988 .dumb_destroy = drm_gem_dumb_destroy, 989 990 .name = DRIVER_NAME, 991 .desc = DRIVER_DESC, 992#ifdef GIT_REVISION 993 .date = GIT_REVISION, 994#else 995 .date = DRIVER_DATE, 996#endif 997 .major = DRIVER_MAJOR, 998 .minor = DRIVER_MINOR, 999 .patchlevel = DRIVER_PATCHLEVEL, 1000}; 1001 1002static struct pci_device_id 1003nouveau_drm_pci_table[] = { 1004 { 1005 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID), 1006 .class = PCI_BASE_CLASS_DISPLAY << 16, 1007 .class_mask = 0xff << 16, 1008 }, 1009 { 1010 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA_SGS, PCI_ANY_ID), 1011 .class = PCI_BASE_CLASS_DISPLAY << 16, 1012 .class_mask = 0xff << 16, 1013 }, 1014 {} 1015}; 1016 1017static void nouveau_display_options(void) 1018{ 1019 DRM_DEBUG_DRIVER("Loading Nouveau with parameters:\n"); 1020 1021 DRM_DEBUG_DRIVER("... tv_disable : %d\n", nouveau_tv_disable); 1022 DRM_DEBUG_DRIVER("... ignorelid : %d\n", nouveau_ignorelid); 1023 DRM_DEBUG_DRIVER("... duallink : %d\n", nouveau_duallink); 1024 DRM_DEBUG_DRIVER("... nofbaccel : %d\n", nouveau_nofbaccel); 1025 DRM_DEBUG_DRIVER("... config : %s\n", nouveau_config); 1026 DRM_DEBUG_DRIVER("... debug : %s\n", nouveau_debug); 1027 DRM_DEBUG_DRIVER("... noaccel : %d\n", nouveau_noaccel); 1028 DRM_DEBUG_DRIVER("... modeset : %d\n", nouveau_modeset); 1029 DRM_DEBUG_DRIVER("... runpm : %d\n", nouveau_runtime_pm); 1030 DRM_DEBUG_DRIVER("... vram_pushbuf : %d\n", nouveau_vram_pushbuf); 1031 DRM_DEBUG_DRIVER("... pstate : %d\n", nouveau_pstate); 1032} 1033 1034static const struct dev_pm_ops nouveau_pm_ops = { 1035 .suspend = nouveau_pmops_suspend, 1036 .resume = nouveau_pmops_resume, 1037 .freeze = nouveau_pmops_freeze, 1038 .thaw = nouveau_pmops_thaw, 1039 .poweroff = nouveau_pmops_freeze, 1040 .restore = nouveau_pmops_resume, 1041 .runtime_suspend = nouveau_pmops_runtime_suspend, 1042 .runtime_resume = nouveau_pmops_runtime_resume, 1043 .runtime_idle = nouveau_pmops_runtime_idle, 1044}; 1045 1046static struct pci_driver 1047nouveau_drm_pci_driver = { 1048 .name = "nouveau", 1049 .id_table = nouveau_drm_pci_table, 1050 .probe = nouveau_drm_probe, 1051 .remove = nouveau_drm_remove, 1052 .driver.pm = &nouveau_pm_ops, 1053}; 1054 1055struct drm_device * 1056nouveau_platform_device_create_(struct platform_device *pdev, int size, 1057 void **pobject) 1058{ 1059 struct drm_device *drm; 1060 int err; 1061 1062 err = nvkm_device_create_(pdev, NVKM_BUS_PLATFORM, 1063 nouveau_platform_name(pdev), 1064 dev_name(&pdev->dev), nouveau_config, 1065 nouveau_debug, size, pobject); 1066 if (err) 1067 return ERR_PTR(err); 1068 1069 drm = drm_dev_alloc(&driver_platform, &pdev->dev); 1070 if (!drm) { 1071 err = -ENOMEM; 1072 goto err_free; 1073 } 1074 1075 err = drm_dev_set_unique(drm, "%s", dev_name(&pdev->dev)); 1076 if (err < 0) 1077 goto err_free; 1078 1079 drm->platformdev = pdev; 1080 platform_set_drvdata(pdev, drm); 1081 1082 return drm; 1083 1084err_free: 1085 nvkm_object_ref(NULL, (struct nvkm_object **)pobject); 1086 1087 return ERR_PTR(err); 1088} 1089 1090static int __init 1091nouveau_drm_init(void) 1092{ 1093 driver_pci = driver_stub; 1094 driver_pci.set_busid = drm_pci_set_busid; 1095 driver_platform = driver_stub; 1096 driver_platform.set_busid = drm_platform_set_busid; 1097 1098 nouveau_display_options(); 1099 1100 if (nouveau_modeset == -1) { 1101#ifdef CONFIG_VGA_CONSOLE 1102 if (vgacon_text_force()) 1103 nouveau_modeset = 0; 1104#endif 1105 } 1106 1107 if (!nouveau_modeset) 1108 return 0; 1109 1110#ifdef CONFIG_NOUVEAU_PLATFORM_DRIVER 1111 platform_driver_register(&nouveau_platform_driver); 1112#endif 1113 1114 nouveau_register_dsm_handler(); 1115 return drm_pci_init(&driver_pci, &nouveau_drm_pci_driver); 1116} 1117 1118static void __exit 1119nouveau_drm_exit(void) 1120{ 1121 if (!nouveau_modeset) 1122 return; 1123 1124 drm_pci_exit(&driver_pci, &nouveau_drm_pci_driver); 1125 nouveau_unregister_dsm_handler(); 1126 1127#ifdef CONFIG_NOUVEAU_PLATFORM_DRIVER 1128 platform_driver_unregister(&nouveau_platform_driver); 1129#endif 1130} 1131 1132module_init(nouveau_drm_init); 1133module_exit(nouveau_drm_exit); 1134 1135MODULE_DEVICE_TABLE(pci, nouveau_drm_pci_table); 1136MODULE_AUTHOR(DRIVER_AUTHOR); 1137MODULE_DESCRIPTION(DRIVER_DESC); 1138MODULE_LICENSE("GPL and additional rights"); 1139