nouveau_drm.c 29.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * Copyright 2012 Red Hat Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: Ben Skeggs
 */

25
#include <linux/console.h>
26
#include <linux/delay.h>
27 28
#include <linux/module.h>
#include <linux/pci.h>
29 30
#include <linux/pm_runtime.h>
#include <linux/vga_switcheroo.h>
31

32 33
#include <drm/drmP.h>
#include <drm/drm_crtc_helper.h>
34

35
#include <core/gpuobj.h>
36
#include <core/option.h>
37 38
#include <core/pci.h>
#include <core/tegra.h>
39

40 41
#include <nvif/driver.h>

42
#include <nvif/class.h>
43
#include <nvif/cl0002.h>
44
#include <nvif/cla06f.h>
45 46
#include <nvif/if0004.h>

47
#include "nouveau_drv.h"
48
#include "nouveau_dma.h"
49 50 51
#include "nouveau_ttm.h"
#include "nouveau_gem.h"
#include "nouveau_vga.h"
52
#include "nouveau_led.h"
53
#include "nouveau_hwmon.h"
54 55 56
#include "nouveau_acpi.h"
#include "nouveau_bios.h"
#include "nouveau_ioctl.h"
57 58 59
#include "nouveau_abi16.h"
#include "nouveau_fbcon.h"
#include "nouveau_fence.h"
60
#include "nouveau_debugfs.h"
61
#include "nouveau_usif.h"
62
#include "nouveau_connector.h"
63
#include "nouveau_platform.h"
64

65 66 67 68 69 70 71 72
MODULE_PARM_DESC(config, "option string to pass to driver core");
static char *nouveau_config;
module_param_named(config, nouveau_config, charp, 0400);

MODULE_PARM_DESC(debug, "debug string to pass to driver core");
static char *nouveau_debug;
module_param_named(debug, nouveau_debug, charp, 0400);

73 74 75 76
MODULE_PARM_DESC(noaccel, "disable kernel/abi16 acceleration");
static int nouveau_noaccel = 0;
module_param_named(noaccel, nouveau_noaccel, int, 0400);

77 78 79
MODULE_PARM_DESC(modeset, "enable driver (default: auto, "
		          "0 = disabled, 1 = enabled, 2 = headless)");
int nouveau_modeset = -1;
80 81
module_param_named(modeset, nouveau_modeset, int, 0400);

82
MODULE_PARM_DESC(runpm, "disable (0), force enable (1), optimus only default (-1)");
83
static int nouveau_runtime_pm = -1;
84 85
module_param_named(runpm, nouveau_runtime_pm, int, 0400);

86 87 88
static struct drm_driver driver_stub;
static struct drm_driver driver_pci;
static struct drm_driver driver_platform;
89

90
static u64
A
Alexandre Courbot 已提交
91
nouveau_pci_name(struct pci_dev *pdev)
92 93 94 95 96 97 98
{
	u64 name = (u64)pci_domain_nr(pdev->bus) << 32;
	name |= pdev->bus->number << 16;
	name |= PCI_SLOT(pdev->devfn) << 8;
	return name | PCI_FUNC(pdev->devfn);
}

A
Alexandre Courbot 已提交
99 100 101 102 103 104 105 106 107 108 109 110
static u64
nouveau_platform_name(struct platform_device *platformdev)
{
	return platformdev->id;
}

static u64
nouveau_name(struct drm_device *dev)
{
	if (dev->pdev)
		return nouveau_pci_name(dev->pdev);
	else
111
		return nouveau_platform_name(to_platform_device(dev->dev));
A
Alexandre Courbot 已提交
112 113
}

114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
static inline bool
nouveau_cli_work_ready(struct dma_fence *fence, bool wait)
{
	if (!dma_fence_is_signaled(fence)) {
		if (!wait)
			return false;
		WARN_ON(dma_fence_wait_timeout(fence, false, 2 * HZ) <= 0);
	}
	dma_fence_put(fence);
	return true;
}

static void
nouveau_cli_work_flush(struct nouveau_cli *cli, bool wait)
{
	struct nouveau_cli_work *work, *wtmp;
	mutex_lock(&cli->lock);
	list_for_each_entry_safe(work, wtmp, &cli->worker, head) {
		if (!work->fence || nouveau_cli_work_ready(work->fence, wait)) {
			list_del(&work->head);
			work->func(work);
		}
	}
	mutex_unlock(&cli->lock);
}

static void
nouveau_cli_work_fence(struct dma_fence *fence, struct dma_fence_cb *cb)
{
	struct nouveau_cli_work *work = container_of(cb, typeof(*work), cb);
	schedule_work(&work->cli->work);
}

void
nouveau_cli_work_queue(struct nouveau_cli *cli, struct dma_fence *fence,
		       struct nouveau_cli_work *work)
{
	work->fence = dma_fence_get(fence);
	work->cli = cli;
	mutex_lock(&cli->lock);
	list_add_tail(&work->head, &cli->worker);
	if (dma_fence_add_callback(fence, &work->cb, nouveau_cli_work_fence))
		nouveau_cli_work_fence(fence, &work->cb);
157
	mutex_unlock(&cli->lock);
158 159 160 161 162 163 164 165 166
}

static void
nouveau_cli_work(struct work_struct *w)
{
	struct nouveau_cli *cli = container_of(w, typeof(*cli), work);
	nouveau_cli_work_flush(cli, false);
}

167 168 169
static void
nouveau_cli_fini(struct nouveau_cli *cli)
{
170
	nouveau_cli_work_flush(cli, true);
171
	usif_client_fini(cli);
172
	nouveau_vmm_fini(&cli->vmm);
173
	nvif_mmu_fini(&cli->mmu);
174
	nvif_device_fini(&cli->device);
175
	mutex_lock(&cli->drm->master.lock);
176
	nvif_client_fini(&cli->base);
177
	mutex_unlock(&cli->drm->master.lock);
178 179
}

180
static int
181 182
nouveau_cli_init(struct nouveau_drm *drm, const char *sname,
		 struct nouveau_cli *cli)
183
{
184 185 186 187 188 189 190
	static const struct nvif_mclass
	mems[] = {
		{ NVIF_CLASS_MEM_GF100, -1 },
		{ NVIF_CLASS_MEM_NV50 , -1 },
		{ NVIF_CLASS_MEM_NV04 , -1 },
		{}
	};
191 192 193 194 195 196 197
	static const struct nvif_mclass
	mmus[] = {
		{ NVIF_CLASS_MMU_GF100, -1 },
		{ NVIF_CLASS_MMU_NV50 , -1 },
		{ NVIF_CLASS_MMU_NV04 , -1 },
		{}
	};
198 199 200 201 202 203 204 205 206
	static const struct nvif_mclass
	vmms[] = {
		{ NVIF_CLASS_VMM_GP100, -1 },
		{ NVIF_CLASS_VMM_GM200, -1 },
		{ NVIF_CLASS_VMM_GF100, -1 },
		{ NVIF_CLASS_VMM_NV50 , -1 },
		{ NVIF_CLASS_VMM_NV04 , -1 },
		{}
	};
207
	u64 device = nouveau_name(drm->dev);
B
Ben Skeggs 已提交
208 209
	int ret;

210
	snprintf(cli->name, sizeof(cli->name), "%s", sname);
211
	cli->drm = drm;
212 213 214
	mutex_init(&cli->mutex);
	usif_client_init(cli);

215 216
	INIT_WORK(&cli->work, nouveau_cli_work);
	INIT_LIST_HEAD(&cli->worker);
217 218 219
	mutex_init(&cli->lock);

	if (cli == &drm->master) {
220 221 222
		ret = nvif_driver_init(NULL, nouveau_config, nouveau_debug,
				       cli->name, device, &cli->base);
	} else {
223 224
		mutex_lock(&drm->master.lock);
		ret = nvif_client_init(&drm->master.base, cli->name, device,
B
Ben Skeggs 已提交
225
				       &cli->base);
226
		mutex_unlock(&drm->master.lock);
227
	}
228 229 230
	if (ret) {
		NV_ERROR(drm, "Client allocation failed: %d\n", ret);
		goto done;
231
	}
232

233 234 235 236 237 238 239 240 241 242
	ret = nvif_device_init(&cli->base.object, 0, NV_DEVICE,
			       &(struct nv_device_v0) {
					.device = ~0,
			       }, sizeof(struct nv_device_v0),
			       &cli->device);
	if (ret) {
		NV_ERROR(drm, "Device allocation failed: %d\n", ret);
		goto done;
	}

243 244 245 246 247 248 249 250 251 252 253 254
	ret = nvif_mclass(&cli->device.object, mmus);
	if (ret < 0) {
		NV_ERROR(drm, "No supported MMU class\n");
		goto done;
	}

	ret = nvif_mmu_init(&cli->device.object, mmus[ret].oclass, &cli->mmu);
	if (ret) {
		NV_ERROR(drm, "MMU allocation failed: %d\n", ret);
		goto done;
	}

255 256 257 258 259 260 261 262 263 264 265 266
	ret = nvif_mclass(&cli->mmu.object, vmms);
	if (ret < 0) {
		NV_ERROR(drm, "No supported VMM class\n");
		goto done;
	}

	ret = nouveau_vmm_init(cli, vmms[ret].oclass, &cli->vmm);
	if (ret) {
		NV_ERROR(drm, "VMM allocation failed: %d\n", ret);
		goto done;
	}

267 268 269 270 271 272 273 274
	ret = nvif_mclass(&cli->mmu.object, mems);
	if (ret < 0) {
		NV_ERROR(drm, "No supported MEM class\n");
		goto done;
	}

	cli->mem = &mems[ret];
	return 0;
275 276 277 278
done:
	if (ret)
		nouveau_cli_fini(cli);
	return ret;
279 280
}

281 282 283
static void
nouveau_accel_fini(struct nouveau_drm *drm)
{
284
	nouveau_channel_idle(drm->channel);
285
	nvif_object_fini(&drm->ntfy);
286
	nvkm_gpuobj_del(&drm->notify);
287
	nvif_notify_fini(&drm->flip);
288
	nvif_object_fini(&drm->nvsw);
289 290 291
	nouveau_channel_del(&drm->channel);

	nouveau_channel_idle(drm->cechan);
292
	nvif_object_fini(&drm->ttm.copy);
293 294
	nouveau_channel_del(&drm->cechan);

295 296 297 298 299 300 301
	if (drm->fence)
		nouveau_fence(drm)->dtor(drm);
}

static void
nouveau_accel_init(struct nouveau_drm *drm)
{
302
	struct nvif_device *device = &drm->client.device;
303
	struct nvif_sclass *sclass;
304
	u32 arg0, arg1;
305
	int ret, i, n;
306

307
	if (nouveau_noaccel)
308 309 310
		return;

	/* initialise synchronisation routines */
311 312 313
	/*XXX: this is crap, but the fence/channel stuff is a little
	 *     backwards in some places.  this will be fixed.
	 */
314
	ret = n = nvif_object_sclass_get(&device->object, &sclass);
315 316 317
	if (ret < 0)
		return;

318 319
	for (ret = -ENOSYS, i = 0; i < n; i++) {
		switch (sclass[i].oclass) {
320
		case NV03_CHANNEL_DMA:
321 322
			ret = nv04_fence_create(drm);
			break;
323
		case NV10_CHANNEL_DMA:
324 325
			ret = nv10_fence_create(drm);
			break;
326 327
		case NV17_CHANNEL_DMA:
		case NV40_CHANNEL_DMA:
328 329
			ret = nv17_fence_create(drm);
			break;
330
		case NV50_CHANNEL_GPFIFO:
331 332
			ret = nv50_fence_create(drm);
			break;
333
		case G82_CHANNEL_GPFIFO:
334 335
			ret = nv84_fence_create(drm);
			break;
336 337
		case FERMI_CHANNEL_GPFIFO:
		case KEPLER_CHANNEL_GPFIFO_A:
338
		case KEPLER_CHANNEL_GPFIFO_B:
339
		case MAXWELL_CHANNEL_GPFIFO_A:
340
		case PASCAL_CHANNEL_GPFIFO_A:
341 342 343 344 345 346 347
			ret = nvc0_fence_create(drm);
			break;
		default:
			break;
		}
	}

348
	nvif_object_sclass_put(&sclass);
349 350 351 352 353 354
	if (ret) {
		NV_ERROR(drm, "failed to initialise sync subsystem, %d\n", ret);
		nouveau_accel_fini(drm);
		return;
	}

355
	if (device->info.family >= NV_DEVICE_INFO_V0_KEPLER) {
356
		ret = nouveau_channel_new(drm, &drm->client.device,
357 358
					  NVA06F_V0_ENGINE_CE0 |
					  NVA06F_V0_ENGINE_CE1,
359
					  0, &drm->cechan);
360 361 362
		if (ret)
			NV_ERROR(drm, "failed to create ce channel, %d\n", ret);

363
		arg0 = NVA06F_V0_ENGINE_GR;
364
		arg1 = 1;
365
	} else
366 367 368
	if (device->info.chipset >= 0xa3 &&
	    device->info.chipset != 0xaa &&
	    device->info.chipset != 0xac) {
369
		ret = nouveau_channel_new(drm, &drm->client.device,
370
					  NvDmaFB, NvDmaTT, &drm->cechan);
371 372 373 374 375
		if (ret)
			NV_ERROR(drm, "failed to create ce channel, %d\n", ret);

		arg0 = NvDmaFB;
		arg1 = NvDmaTT;
376 377 378 379 380
	} else {
		arg0 = NvDmaFB;
		arg1 = NvDmaTT;
	}

381 382
	ret = nouveau_channel_new(drm, &drm->client.device,
				  arg0, arg1, &drm->channel);
383 384 385 386 387 388
	if (ret) {
		NV_ERROR(drm, "failed to create kernel channel, %d\n", ret);
		nouveau_accel_fini(drm);
		return;
	}

389
	ret = nvif_object_init(&drm->channel->user, NVDRM_NVSW,
390
			       nouveau_abi16_swclass(drm), NULL, 0, &drm->nvsw);
391 392 393
	if (ret == 0) {
		ret = RING_SPACE(drm->channel, 2);
		if (ret == 0) {
394
			if (device->info.family < NV_DEVICE_INFO_V0_FERMI) {
395 396 397
				BEGIN_NV04(drm->channel, NvSubSw, 0, 1);
				OUT_RING  (drm->channel, NVDRM_NVSW);
			} else
398
			if (device->info.family < NV_DEVICE_INFO_V0_KEPLER) {
399 400 401 402
				BEGIN_NVC0(drm->channel, FermiSw, 0, 1);
				OUT_RING  (drm->channel, 0x001f0000);
			}
		}
403 404

		ret = nvif_notify_init(&drm->nvsw, nouveau_flip_complete,
405 406
				       false, NV04_NVSW_NTFY_UEVENT,
				       NULL, 0, 0, &drm->flip);
407 408 409 410 411 412
		if (ret == 0)
			ret = nvif_notify_get(&drm->flip);
		if (ret) {
			nouveau_accel_fini(drm);
			return;
		}
413 414 415 416 417 418 419 420
	}

	if (ret) {
		NV_ERROR(drm, "failed to allocate software object, %d\n", ret);
		nouveau_accel_fini(drm);
		return;
	}

421
	if (device->info.family < NV_DEVICE_INFO_V0_FERMI) {
422 423
		ret = nvkm_gpuobj_new(nvxx_device(&drm->client.device), 32, 0,
				      false, NULL, &drm->notify);
424 425 426 427 428 429
		if (ret) {
			NV_ERROR(drm, "failed to allocate notifier, %d\n", ret);
			nouveau_accel_fini(drm);
			return;
		}

430
		ret = nvif_object_init(&drm->channel->user, NvNotify0,
431 432 433 434
				       NV_DMA_IN_MEMORY,
				       &(struct nv_dma_v0) {
						.target = NV_DMA_V0_TARGET_VRAM,
						.access = NV_DMA_V0_ACCESS_RDWR,
435 436
						.start = drm->notify->addr,
						.limit = drm->notify->addr + 31
437
				       }, sizeof(struct nv_dma_v0),
438
				       &drm->ntfy);
439 440 441 442 443 444 445
		if (ret) {
			nouveau_accel_fini(drm);
			return;
		}
	}


446
	nouveau_bo_move_init(drm);
447 448
}

449 450
static int nouveau_drm_probe(struct pci_dev *pdev,
			     const struct pci_device_id *pent)
451
{
452
	struct nvkm_device *device;
453 454
	struct apertures_struct *aper;
	bool boot = false;
455 456
	int ret;

457
	if (vga_switcheroo_client_probe_defer(pdev))
458 459
		return -EPROBE_DEFER;

460 461 462 463 464 465 466 467 468 469
	/* We need to check that the chipset is supported before booting
	 * fbdev off the hardware, as there's no way to put it back.
	 */
	ret = nvkm_device_pci_new(pdev, NULL, "error", true, false, 0, &device);
	if (ret)
		return ret;

	nvkm_device_del(&device);

	/* Remove conflicting drivers (vesafb, efifb etc). */
470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
	aper = alloc_apertures(3);
	if (!aper)
		return -ENOMEM;

	aper->ranges[0].base = pci_resource_start(pdev, 1);
	aper->ranges[0].size = pci_resource_len(pdev, 1);
	aper->count = 1;

	if (pci_resource_len(pdev, 2)) {
		aper->ranges[aper->count].base = pci_resource_start(pdev, 2);
		aper->ranges[aper->count].size = pci_resource_len(pdev, 2);
		aper->count++;
	}

	if (pci_resource_len(pdev, 3)) {
		aper->ranges[aper->count].base = pci_resource_start(pdev, 3);
		aper->ranges[aper->count].size = pci_resource_len(pdev, 3);
		aper->count++;
	}

#ifdef CONFIG_X86
	boot = pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW;
#endif
B
Ben Skeggs 已提交
493
	if (nouveau_modeset != 2)
494
		drm_fb_helper_remove_conflicting_framebuffers(aper, "nouveaufb", boot);
495
	kfree(aper);
496

497 498
	ret = nvkm_device_pci_new(pdev, nouveau_config, nouveau_debug,
				  true, true, ~0ULL, &device);
499 500 501 502 503
	if (ret)
		return ret;

	pci_set_master(pdev);

504
	ret = drm_get_pci_dev(pdev, pent, &driver_pci);
505
	if (ret) {
506
		nvkm_device_del(&device);
507 508 509 510 511 512
		return ret;
	}

	return 0;
}

513
static int
514 515 516 517 518
nouveau_drm_load(struct drm_device *dev, unsigned long flags)
{
	struct nouveau_drm *drm;
	int ret;

519 520 521 522 523
	if (!(drm = kzalloc(sizeof(*drm), GFP_KERNEL)))
		return -ENOMEM;
	dev->dev_private = drm;
	drm->dev = dev;

524 525 526 527
	ret = nouveau_cli_init(drm, "DRM-master", &drm->master);
	if (ret)
		return ret;

528
	ret = nouveau_cli_init(drm, "DRM", &drm->client);
529 530 531
	if (ret)
		return ret;

532 533
	dev->irq_enabled = true;

534
	nvxx_client(&drm->client.base)->debug =
535
		nvkm_dbgopt(nouveau_debug, "DRM");
536

537
	INIT_LIST_HEAD(&drm->clients);
538
	spin_lock_init(&drm->tile.lock);
539

540 541 542 543
	/* workaround an odd issue on nvc1 by disabling the device's
	 * nosnoop capability.  hopefully won't cause issues until a
	 * better fix is found - assuming there is one...
	 */
544 545
	if (drm->client.device.info.chipset == 0xc1)
		nvif_mask(&drm->client.device.object, 0x00088080, 0x00000800, 0x00000000);
546

547
	nouveau_vga_init(drm);
548

549
	ret = nouveau_ttm_init(drm);
550
	if (ret)
551 552 553 554 555 556 557
		goto fail_ttm;

	ret = nouveau_bios_init(dev);
	if (ret)
		goto fail_bios;

	ret = nouveau_display_create(dev);
558
	if (ret)
559 560 561 562 563 564 565 566
		goto fail_dispctor;

	if (dev->mode_config.num_crtc) {
		ret = nouveau_display_init(dev);
		if (ret)
			goto fail_dispinit;
	}

567
	nouveau_debugfs_init(drm);
568
	nouveau_hwmon_init(dev);
569 570
	nouveau_accel_init(drm);
	nouveau_fbcon_init(dev);
571
	nouveau_led_init(dev);
572

573
	if (nouveau_pmops_runtime()) {
574 575 576 577 578 579
		pm_runtime_use_autosuspend(dev->dev);
		pm_runtime_set_autosuspend_delay(dev->dev, 5000);
		pm_runtime_set_active(dev->dev);
		pm_runtime_allow(dev->dev);
		pm_runtime_mark_last_busy(dev->dev);
		pm_runtime_put(dev->dev);
580 581 582
	} else {
		/* enable polling for external displays */
		drm_kms_helper_poll_enable(dev);
583
	}
584 585
	return 0;

586 587 588 589 590
fail_dispinit:
	nouveau_display_destroy(dev);
fail_dispctor:
	nouveau_bios_takedown(dev);
fail_bios:
591
	nouveau_ttm_fini(drm);
592 593
fail_ttm:
	nouveau_vga_fini(drm);
594
	nouveau_cli_fini(&drm->client);
595
	nouveau_cli_fini(&drm->master);
596
	kfree(drm);
597 598 599
	return ret;
}

600
static void
601 602
nouveau_drm_unload(struct drm_device *dev)
{
603
	struct nouveau_drm *drm = nouveau_drm(dev);
604

605
	if (nouveau_pmops_runtime()) {
606
		pm_runtime_get_sync(dev->dev);
607
		pm_runtime_forbid(dev->dev);
608 609
	}

610
	nouveau_led_fini(dev);
611 612
	nouveau_fbcon_fini(dev);
	nouveau_accel_fini(drm);
613
	nouveau_hwmon_fini(dev);
614
	nouveau_debugfs_fini(drm);
615

616
	if (dev->mode_config.num_crtc)
617
		nouveau_display_fini(dev, false);
618 619 620
	nouveau_display_destroy(dev);

	nouveau_bios_takedown(dev);
621

622
	nouveau_ttm_fini(drm);
623
	nouveau_vga_fini(drm);
624

625
	nouveau_cli_fini(&drm->client);
626
	nouveau_cli_fini(&drm->master);
627
	kfree(drm);
628 629
}

630 631
void
nouveau_drm_device_remove(struct drm_device *dev)
632
{
633
	struct nouveau_drm *drm = nouveau_drm(dev);
634
	struct nvkm_client *client;
635
	struct nvkm_device *device;
636

637
	dev->irq_enabled = false;
638
	client = nvxx_client(&drm->client.base);
639
	device = nvkm_device_find(client->device);
640 641
	drm_put_dev(dev);

642
	nvkm_device_del(&device);
643
}
644 645 646 647 648 649 650 651

static void
nouveau_drm_remove(struct pci_dev *pdev)
{
	struct drm_device *dev = pci_get_drvdata(pdev);

	nouveau_drm_device_remove(dev);
}
652

653
static int
654
nouveau_do_suspend(struct drm_device *dev, bool runtime)
655
{
656
	struct nouveau_drm *drm = nouveau_drm(dev);
657 658
	int ret;

659 660
	nouveau_led_suspend(dev);

661
	if (dev->mode_config.num_crtc) {
662
		NV_DEBUG(drm, "suspending console...\n");
663
		nouveau_fbcon_set_suspend(dev, 1);
664
		NV_DEBUG(drm, "suspending display...\n");
665
		ret = nouveau_display_suspend(dev, runtime);
666 667 668
		if (ret)
			return ret;
	}
669

670
	NV_DEBUG(drm, "evicting buffers...\n");
671 672
	ttm_bo_evict_mm(&drm->ttm.bdev, TTM_PL_VRAM);

673
	NV_DEBUG(drm, "waiting for kernel channels to go idle...\n");
674 675 676
	if (drm->cechan) {
		ret = nouveau_channel_idle(drm->cechan);
		if (ret)
677
			goto fail_display;
678 679 680 681 682
	}

	if (drm->channel) {
		ret = nouveau_channel_idle(drm->channel);
		if (ret)
683
			goto fail_display;
684 685
	}

686
	NV_DEBUG(drm, "suspending fence...\n");
687
	if (drm->fence && nouveau_fence(drm)->suspend) {
688 689 690 691
		if (!nouveau_fence(drm)->suspend(drm)) {
			ret = -ENOMEM;
			goto fail_display;
		}
692 693
	}

694
	NV_DEBUG(drm, "suspending object tree...\n");
695
	ret = nvif_client_suspend(&drm->master.base);
696 697 698 699 700 701
	if (ret)
		goto fail_client;

	return 0;

fail_client:
702 703 704 705
	if (drm->fence && nouveau_fence(drm)->resume)
		nouveau_fence(drm)->resume(drm);

fail_display:
706
	if (dev->mode_config.num_crtc) {
707
		NV_DEBUG(drm, "resuming display...\n");
708
		nouveau_display_resume(dev, runtime);
709
	}
710 711 712
	return ret;
}

713
static int
714
nouveau_do_resume(struct drm_device *dev, bool runtime)
D
Dave Airlie 已提交
715 716 717
{
	struct nouveau_drm *drm = nouveau_drm(dev);

718
	NV_DEBUG(drm, "resuming object tree...\n");
719
	nvif_client_resume(&drm->master.base);
720

721
	NV_DEBUG(drm, "resuming fence...\n");
722 723 724
	if (drm->fence && nouveau_fence(drm)->resume)
		nouveau_fence(drm)->resume(drm);

725 726
	nouveau_run_vbios_init(dev);

727
	if (dev->mode_config.num_crtc) {
728
		NV_DEBUG(drm, "resuming display...\n");
729
		nouveau_display_resume(dev, runtime);
730
		NV_DEBUG(drm, "resuming console...\n");
731
		nouveau_fbcon_set_suspend(dev, 0);
732
	}
733

734 735
	nouveau_led_resume(dev);

736
	return 0;
737 738
}

739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
int
nouveau_pmops_suspend(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
	int ret;

	if (drm_dev->switch_power_state == DRM_SWITCH_POWER_OFF ||
	    drm_dev->switch_power_state == DRM_SWITCH_POWER_DYNAMIC_OFF)
		return 0;

	ret = nouveau_do_suspend(drm_dev, false);
	if (ret)
		return ret;

	pci_save_state(pdev);
	pci_disable_device(pdev);
	pci_set_power_state(pdev, PCI_D3hot);
757
	udelay(200);
758 759 760 761 762
	return 0;
}

int
nouveau_pmops_resume(struct device *dev)
D
Dave Airlie 已提交
763 764 765 766 767
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
	int ret;

768 769
	if (drm_dev->switch_power_state == DRM_SWITCH_POWER_OFF ||
	    drm_dev->switch_power_state == DRM_SWITCH_POWER_DYNAMIC_OFF)
D
Dave Airlie 已提交
770 771 772 773 774 775 776 777 778
		return 0;

	pci_set_power_state(pdev, PCI_D0);
	pci_restore_state(pdev);
	ret = pci_enable_device(pdev);
	if (ret)
		return ret;
	pci_set_master(pdev);

779 780 781 782 783 784
	ret = nouveau_do_resume(drm_dev, false);

	/* Monitors may have been connected / disconnected during suspend */
	schedule_work(&nouveau_drm(drm_dev)->hpd_work);

	return ret;
D
Dave Airlie 已提交
785 786
}

787 788
static int
nouveau_pmops_freeze(struct device *dev)
D
Dave Airlie 已提交
789 790 791
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
792
	return nouveau_do_suspend(drm_dev, false);
D
Dave Airlie 已提交
793 794
}

795 796
static int
nouveau_pmops_thaw(struct device *dev)
D
Dave Airlie 已提交
797 798 799
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
800
	return nouveau_do_resume(drm_dev, false);
D
Dave Airlie 已提交
801 802
}

803
bool
804
nouveau_pmops_runtime(void)
805 806 807 808 809 810
{
	if (nouveau_runtime_pm == -1)
		return nouveau_is_optimus() || nouveau_is_v1_dsm();
	return nouveau_runtime_pm == 1;
}

811 812 813 814 815 816 817
static int
nouveau_pmops_runtime_suspend(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
	int ret;

818
	if (!nouveau_pmops_runtime()) {
819 820 821 822 823 824 825 826 827
		pm_runtime_forbid(dev);
		return -EBUSY;
	}

	drm_kms_helper_poll_disable(drm_dev);
	nouveau_switcheroo_optimus_dsm();
	ret = nouveau_do_suspend(drm_dev, true);
	pci_save_state(pdev);
	pci_disable_device(pdev);
D
Dave Airlie 已提交
828
	pci_ignore_hotplug(pdev);
829 830 831 832 833 834 835 836 837 838
	pci_set_power_state(pdev, PCI_D3cold);
	drm_dev->switch_power_state = DRM_SWITCH_POWER_DYNAMIC_OFF;
	return ret;
}

static int
nouveau_pmops_runtime_resume(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
839
	struct nvif_device *device = &nouveau_drm(drm_dev)->client.device;
840 841
	int ret;

842 843 844 845
	if (!nouveau_pmops_runtime()) {
		pm_runtime_forbid(dev);
		return -EBUSY;
	}
846 847 848 849 850 851 852 853 854

	pci_set_power_state(pdev, PCI_D0);
	pci_restore_state(pdev);
	ret = pci_enable_device(pdev);
	if (ret)
		return ret;
	pci_set_master(pdev);

	ret = nouveau_do_resume(drm_dev, true);
855

856
	/* do magic */
857
	nvif_mask(&device->object, 0x088488, (1 << 25), (1 << 25));
858
	drm_dev->switch_power_state = DRM_SWITCH_POWER_ON;
859 860 861 862

	/* Monitors may have been connected / disconnected during suspend */
	schedule_work(&nouveau_drm(drm_dev)->hpd_work);

863 864 865 866 867 868 869 870 871 872 873
	return ret;
}

static int
nouveau_pmops_runtime_idle(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
	struct nouveau_drm *drm = nouveau_drm(drm_dev);
	struct drm_crtc *crtc;

874
	if (!nouveau_pmops_runtime()) {
875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
		pm_runtime_forbid(dev);
		return -EBUSY;
	}

	list_for_each_entry(crtc, &drm->dev->mode_config.crtc_list, head) {
		if (crtc->enabled) {
			DRM_DEBUG_DRIVER("failing to power off - crtc active\n");
			return -EBUSY;
		}
	}
	pm_runtime_mark_last_busy(dev);
	pm_runtime_autosuspend(dev);
	/* we don't want the main rpm_idle to call suspend - we want to autosuspend */
	return 1;
}
D
Dave Airlie 已提交
890

891
static int
892 893 894 895
nouveau_drm_open(struct drm_device *dev, struct drm_file *fpriv)
{
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nouveau_cli *cli;
896
	char name[32], tmpname[TASK_COMM_LEN];
897 898
	int ret;

899 900
	/* need to bring up power immediately if opening device */
	ret = pm_runtime_get_sync(dev->dev);
901
	if (ret < 0 && ret != -EACCES)
902 903
		return ret;

904 905
	get_task_comm(tmpname, current);
	snprintf(name, sizeof(name), "%s[%d]", tmpname, pid_nr(fpriv->pid));
906

907 908
	if (!(cli = kzalloc(sizeof(*cli), GFP_KERNEL)))
		return ret;
A
Alexandre Courbot 已提交
909

910
	ret = nouveau_cli_init(drm, name, cli);
911
	if (ret)
912
		goto done;
913

914 915
	cli->base.super = false;

916 917 918 919 920
	fpriv->driver_priv = cli;

	mutex_lock(&drm->client.mutex);
	list_add(&cli->head, &drm->clients);
	mutex_unlock(&drm->client.mutex);
921

922 923 924 925 926 927
done:
	if (ret && cli) {
		nouveau_cli_fini(cli);
		kfree(cli);
	}

928 929 930
	pm_runtime_mark_last_busy(dev->dev);
	pm_runtime_put_autosuspend(dev->dev);
	return ret;
931 932
}

933
static void
934
nouveau_drm_postclose(struct drm_device *dev, struct drm_file *fpriv)
935 936 937 938
{
	struct nouveau_cli *cli = nouveau_cli(fpriv);
	struct nouveau_drm *drm = nouveau_drm(dev);

939 940
	pm_runtime_get_sync(dev->dev);

941
	mutex_lock(&cli->mutex);
942 943
	if (cli->abi16)
		nouveau_abi16_fini(cli->abi16);
944
	mutex_unlock(&cli->mutex);
945 946 947 948

	mutex_lock(&drm->client.mutex);
	list_del(&cli->head);
	mutex_unlock(&drm->client.mutex);
949

950 951
	nouveau_cli_fini(cli);
	kfree(cli);
952 953
	pm_runtime_mark_last_busy(dev->dev);
	pm_runtime_put_autosuspend(dev->dev);
954 955
}

R
Rob Clark 已提交
956
static const struct drm_ioctl_desc
957
nouveau_ioctls[] = {
958 959 960 961 962 963 964 965 966 967 968 969
	DRM_IOCTL_DEF_DRV(NOUVEAU_GETPARAM, nouveau_abi16_ioctl_getparam, DRM_AUTH|DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(NOUVEAU_SETPARAM, nouveau_abi16_ioctl_setparam, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
	DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_ALLOC, nouveau_abi16_ioctl_channel_alloc, DRM_AUTH|DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_FREE, nouveau_abi16_ioctl_channel_free, DRM_AUTH|DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(NOUVEAU_GROBJ_ALLOC, nouveau_abi16_ioctl_grobj_alloc, DRM_AUTH|DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(NOUVEAU_NOTIFIEROBJ_ALLOC, nouveau_abi16_ioctl_notifierobj_alloc, DRM_AUTH|DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(NOUVEAU_GPUOBJ_FREE, nouveau_abi16_ioctl_gpuobj_free, DRM_AUTH|DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_NEW, nouveau_gem_ioctl_new, DRM_AUTH|DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_PUSHBUF, nouveau_gem_ioctl_pushbuf, DRM_AUTH|DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_PREP, nouveau_gem_ioctl_cpu_prep, DRM_AUTH|DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_FINI, nouveau_gem_ioctl_cpu_fini, DRM_AUTH|DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_INFO, nouveau_gem_ioctl_info, DRM_AUTH|DRM_RENDER_ALLOW),
970 971
};

972 973
long
nouveau_drm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
974
{
975 976
	struct drm_file *filp = file->private_data;
	struct drm_device *dev = filp->minor->dev;
977 978 979
	long ret;

	ret = pm_runtime_get_sync(dev->dev);
980
	if (ret < 0 && ret != -EACCES)
981 982
		return ret;

983 984 985 986 987 988 989 990
	switch (_IOC_NR(cmd) - DRM_COMMAND_BASE) {
	case DRM_NOUVEAU_NVIF:
		ret = usif_ioctl(filp, (void __user *)arg, _IOC_SIZE(cmd));
		break;
	default:
		ret = drm_ioctl(file, cmd, arg);
		break;
	}
991 992 993 994 995

	pm_runtime_mark_last_busy(dev->dev);
	pm_runtime_put_autosuspend(dev->dev);
	return ret;
}
996

997 998 999 1000 1001
static const struct file_operations
nouveau_driver_fops = {
	.owner = THIS_MODULE,
	.open = drm_open,
	.release = drm_release,
1002
	.unlocked_ioctl = nouveau_drm_ioctl,
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
	.mmap = nouveau_ttm_mmap,
	.poll = drm_poll,
	.read = drm_read,
#if defined(CONFIG_COMPAT)
	.compat_ioctl = nouveau_compat_ioctl,
#endif
	.llseek = noop_llseek,
};

static struct drm_driver
1013
driver_stub = {
1014
	.driver_features =
1015 1016
		DRIVER_GEM | DRIVER_MODESET | DRIVER_PRIME | DRIVER_RENDER |
		DRIVER_KMS_LEGACY_CONTEXT,
1017 1018 1019 1020 1021 1022 1023

	.load = nouveau_drm_load,
	.unload = nouveau_drm_unload,
	.open = nouveau_drm_open,
	.postclose = nouveau_drm_postclose,
	.lastclose = nouveau_vga_lastclose,

1024
#if defined(CONFIG_DEBUG_FS)
1025
	.debugfs_init = nouveau_drm_debugfs_init,
1026 1027
#endif

1028 1029
	.enable_vblank = nouveau_display_vblank_enable,
	.disable_vblank = nouveau_display_vblank_disable,
1030
	.get_scanout_position = nouveau_display_scanoutpos,
1031
	.get_vblank_timestamp = drm_calc_vbltimestamp_from_scanoutpos,
1032 1033

	.ioctls = nouveau_ioctls,
R
Rob Clark 已提交
1034
	.num_ioctls = ARRAY_SIZE(nouveau_ioctls),
1035 1036 1037 1038
	.fops = &nouveau_driver_fops,

	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
A
Aaron Plattner 已提交
1039 1040 1041
	.gem_prime_export = drm_gem_prime_export,
	.gem_prime_import = drm_gem_prime_import,
	.gem_prime_pin = nouveau_gem_prime_pin,
1042
	.gem_prime_res_obj = nouveau_gem_prime_res_obj,
1043
	.gem_prime_unpin = nouveau_gem_prime_unpin,
A
Aaron Plattner 已提交
1044 1045 1046 1047
	.gem_prime_get_sg_table = nouveau_gem_prime_get_sg_table,
	.gem_prime_import_sg_table = nouveau_gem_prime_import_sg_table,
	.gem_prime_vmap = nouveau_gem_prime_vmap,
	.gem_prime_vunmap = nouveau_gem_prime_vunmap,
1048

1049
	.gem_free_object_unlocked = nouveau_gem_object_del,
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
	.gem_open_object = nouveau_gem_object_open,
	.gem_close_object = nouveau_gem_object_close,

	.dumb_create = nouveau_display_dumb_create,
	.dumb_map_offset = nouveau_display_dumb_map_offset,

	.name = DRIVER_NAME,
	.desc = DRIVER_DESC,
#ifdef GIT_REVISION
	.date = GIT_REVISION,
#else
	.date = DRIVER_DATE,
#endif
	.major = DRIVER_MAJOR,
	.minor = DRIVER_MINOR,
	.patchlevel = DRIVER_PATCHLEVEL,
};

1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
static struct pci_device_id
nouveau_drm_pci_table[] = {
	{
		PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID),
		.class = PCI_BASE_CLASS_DISPLAY << 16,
		.class_mask  = 0xff << 16,
	},
	{
		PCI_DEVICE(PCI_VENDOR_ID_NVIDIA_SGS, PCI_ANY_ID),
		.class = PCI_BASE_CLASS_DISPLAY << 16,
		.class_mask  = 0xff << 16,
	},
	{}
};

1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
static void nouveau_display_options(void)
{
	DRM_DEBUG_DRIVER("Loading Nouveau with parameters:\n");

	DRM_DEBUG_DRIVER("... tv_disable   : %d\n", nouveau_tv_disable);
	DRM_DEBUG_DRIVER("... ignorelid    : %d\n", nouveau_ignorelid);
	DRM_DEBUG_DRIVER("... duallink     : %d\n", nouveau_duallink);
	DRM_DEBUG_DRIVER("... nofbaccel    : %d\n", nouveau_nofbaccel);
	DRM_DEBUG_DRIVER("... config       : %s\n", nouveau_config);
	DRM_DEBUG_DRIVER("... debug        : %s\n", nouveau_debug);
	DRM_DEBUG_DRIVER("... noaccel      : %d\n", nouveau_noaccel);
	DRM_DEBUG_DRIVER("... modeset      : %d\n", nouveau_modeset);
	DRM_DEBUG_DRIVER("... runpm        : %d\n", nouveau_runtime_pm);
	DRM_DEBUG_DRIVER("... vram_pushbuf : %d\n", nouveau_vram_pushbuf);
1097
	DRM_DEBUG_DRIVER("... hdmimhz      : %d\n", nouveau_hdmimhz);
1098 1099
}

D
Dave Airlie 已提交
1100 1101 1102 1103 1104 1105 1106
static const struct dev_pm_ops nouveau_pm_ops = {
	.suspend = nouveau_pmops_suspend,
	.resume = nouveau_pmops_resume,
	.freeze = nouveau_pmops_freeze,
	.thaw = nouveau_pmops_thaw,
	.poweroff = nouveau_pmops_freeze,
	.restore = nouveau_pmops_resume,
1107 1108 1109
	.runtime_suspend = nouveau_pmops_runtime_suspend,
	.runtime_resume = nouveau_pmops_runtime_resume,
	.runtime_idle = nouveau_pmops_runtime_idle,
D
Dave Airlie 已提交
1110 1111
};

1112 1113 1114 1115 1116 1117
static struct pci_driver
nouveau_drm_pci_driver = {
	.name = "nouveau",
	.id_table = nouveau_drm_pci_table,
	.probe = nouveau_drm_probe,
	.remove = nouveau_drm_remove,
D
Dave Airlie 已提交
1118
	.driver.pm = &nouveau_pm_ops,
1119 1120
};

1121
struct drm_device *
1122 1123
nouveau_platform_device_create(const struct nvkm_device_tegra_func *func,
			       struct platform_device *pdev,
1124
			       struct nvkm_device **pdevice)
A
Alexandre Courbot 已提交
1125
{
1126 1127
	struct drm_device *drm;
	int err;
A
Alexandre Courbot 已提交
1128

1129
	err = nvkm_device_tegra_new(func, pdev, nouveau_config, nouveau_debug,
1130
				    true, true, ~0ULL, pdevice);
1131
	if (err)
1132
		goto err_free;
1133

1134
	drm = drm_dev_alloc(&driver_platform, &pdev->dev);
1135 1136
	if (IS_ERR(drm)) {
		err = PTR_ERR(drm);
1137
		goto err_free;
A
Alexandre Courbot 已提交
1138 1139
	}

1140 1141 1142 1143 1144
	platform_set_drvdata(pdev, drm);

	return drm;

err_free:
1145
	nvkm_device_del(pdevice);
1146 1147

	return ERR_PTR(err);
A
Alexandre Courbot 已提交
1148 1149
}

1150 1151 1152
static int __init
nouveau_drm_init(void)
{
1153 1154 1155
	driver_pci = driver_stub;
	driver_platform = driver_stub;

1156 1157
	nouveau_display_options();

1158 1159 1160 1161 1162 1163 1164 1165
	if (nouveau_modeset == -1) {
		if (vgacon_text_force())
			nouveau_modeset = 0;
	}

	if (!nouveau_modeset)
		return 0;

1166 1167 1168 1169
#ifdef CONFIG_NOUVEAU_PLATFORM_DRIVER
	platform_driver_register(&nouveau_platform_driver);
#endif

1170
	nouveau_register_dsm_handler();
1171
	nouveau_backlight_ctor();
1172 1173 1174 1175 1176 1177

#ifdef CONFIG_PCI
	return pci_register_driver(&nouveau_drm_pci_driver);
#else
	return 0;
#endif
1178 1179 1180 1181 1182
}

static void __exit
nouveau_drm_exit(void)
{
1183 1184 1185
	if (!nouveau_modeset)
		return;

1186 1187 1188
#ifdef CONFIG_PCI
	pci_unregister_driver(&nouveau_drm_pci_driver);
#endif
1189
	nouveau_backlight_dtor();
1190
	nouveau_unregister_dsm_handler();
1191 1192 1193 1194

#ifdef CONFIG_NOUVEAU_PLATFORM_DRIVER
	platform_driver_unregister(&nouveau_platform_driver);
#endif
1195 1196 1197 1198 1199 1200
}

module_init(nouveau_drm_init);
module_exit(nouveau_drm_exit);

MODULE_DEVICE_TABLE(pci, nouveau_drm_pci_table);
1201 1202
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
1203
MODULE_LICENSE("GPL and additional rights");