2 * Copyright 2012 Red Hat Inc.
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:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
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.
25 #include <linux/console.h>
26 #include <linux/module.h>
27 #include <linux/pci.h>
29 #include <core/device.h>
30 #include <core/client.h>
31 #include <core/gpuobj.h>
32 #include <core/class.h>
34 #include <subdev/device.h>
35 #include <subdev/vm.h>
37 #include "nouveau_drm.h"
38 #include "nouveau_irq.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_pm.h"
45 #include "nouveau_acpi.h"
46 #include "nouveau_bios.h"
47 #include "nouveau_ioctl.h"
48 #include "nouveau_abi16.h"
49 #include "nouveau_fbcon.h"
50 #include "nouveau_fence.h"
52 #include "nouveau_ttm.h"
54 MODULE_PARM_DESC(config
, "option string to pass to driver core");
55 static char *nouveau_config
;
56 module_param_named(config
, nouveau_config
, charp
, 0400);
58 MODULE_PARM_DESC(debug
, "debug string to pass to driver core");
59 static char *nouveau_debug
;
60 module_param_named(debug
, nouveau_debug
, charp
, 0400);
62 MODULE_PARM_DESC(noaccel
, "disable kernel/abi16 acceleration");
63 static int nouveau_noaccel
= 0;
64 module_param_named(noaccel
, nouveau_noaccel
, int, 0400);
66 MODULE_PARM_DESC(modeset
, "enable driver");
67 int nouveau_modeset
= -1;
68 module_param_named(modeset
, nouveau_modeset
, int, 0400);
70 static struct drm_driver driver
;
73 nouveau_name(struct pci_dev
*pdev
)
75 u64 name
= (u64
)pci_domain_nr(pdev
->bus
) << 32;
76 name
|= pdev
->bus
->number
<< 16;
77 name
|= PCI_SLOT(pdev
->devfn
) << 8;
78 return name
| PCI_FUNC(pdev
->devfn
);
82 nouveau_cli_create(struct pci_dev
*pdev
, u32 name
, int size
, void **pcli
)
84 struct nouveau_cli
*cli
;
87 ret
= nouveau_client_create_(name
, nouveau_name(pdev
), nouveau_config
,
88 nouveau_debug
, size
, pcli
);
93 mutex_init(&cli
->mutex
);
98 nouveau_cli_destroy(struct nouveau_cli
*cli
)
100 struct nouveau_object
*client
= nv_object(cli
);
101 nouveau_vm_ref(NULL
, &cli
->base
.vm
, NULL
);
102 nouveau_client_fini(&cli
->base
, false);
103 atomic_set(&client
->refcount
, 1);
104 nouveau_object_ref(NULL
, &client
);
108 nouveau_accel_fini(struct nouveau_drm
*drm
)
110 nouveau_gpuobj_ref(NULL
, &drm
->notify
);
111 nouveau_channel_del(&drm
->channel
);
113 nouveau_fence(drm
)->dtor(drm
);
117 nouveau_accel_init(struct nouveau_drm
*drm
)
119 struct nouveau_device
*device
= nv_device(drm
->device
);
120 struct nouveau_object
*object
;
126 /* initialise synchronisation routines */
127 if (device
->card_type
< NV_10
) ret
= nv04_fence_create(drm
);
128 else if (device
->chipset
< 0x84) ret
= nv10_fence_create(drm
);
129 else if (device
->card_type
< NV_C0
) ret
= nv84_fence_create(drm
);
130 else ret
= nvc0_fence_create(drm
);
132 NV_ERROR(drm
, "failed to initialise sync subsystem, %d\n", ret
);
133 nouveau_accel_fini(drm
);
137 ret
= nouveau_channel_new(drm
, &drm
->client
, NVDRM_DEVICE
, NVDRM_CHAN
,
138 NvDmaFB
, NvDmaTT
, &drm
->channel
);
140 NV_ERROR(drm
, "failed to create kernel channel, %d\n", ret
);
141 nouveau_accel_fini(drm
);
145 if (device
->card_type
< NV_C0
) {
146 ret
= nouveau_gpuobj_new(drm
->device
, NULL
, 32, 0, 0,
149 NV_ERROR(drm
, "failed to allocate notifier, %d\n", ret
);
150 nouveau_accel_fini(drm
);
154 ret
= nouveau_object_new(nv_object(drm
),
155 drm
->channel
->handle
, NvNotify0
,
156 0x003d, &(struct nv_dma_class
) {
157 .flags
= NV_DMA_TARGET_VRAM
|
159 .start
= drm
->notify
->addr
,
160 .limit
= drm
->notify
->addr
+ 31
161 }, sizeof(struct nv_dma_class
),
164 nouveau_accel_fini(drm
);
170 nouveau_bo_move_init(drm
->channel
);
174 nouveau_drm_probe(struct pci_dev
*pdev
, const struct pci_device_id
*pent
)
176 struct nouveau_device
*device
;
177 struct apertures_struct
*aper
;
181 /* remove conflicting drivers (vesafb, efifb etc) */
182 aper
= alloc_apertures(3);
186 aper
->ranges
[0].base
= pci_resource_start(pdev
, 1);
187 aper
->ranges
[0].size
= pci_resource_len(pdev
, 1);
190 if (pci_resource_len(pdev
, 2)) {
191 aper
->ranges
[aper
->count
].base
= pci_resource_start(pdev
, 2);
192 aper
->ranges
[aper
->count
].size
= pci_resource_len(pdev
, 2);
196 if (pci_resource_len(pdev
, 3)) {
197 aper
->ranges
[aper
->count
].base
= pci_resource_start(pdev
, 3);
198 aper
->ranges
[aper
->count
].size
= pci_resource_len(pdev
, 3);
203 boot
= pdev
->resource
[PCI_ROM_RESOURCE
].flags
& IORESOURCE_ROM_SHADOW
;
205 remove_conflicting_framebuffers(aper
, "nouveaufb", boot
);
207 ret
= nouveau_device_create(pdev
, nouveau_name(pdev
), pci_name(pdev
),
208 nouveau_config
, nouveau_debug
, &device
);
212 pci_set_master(pdev
);
214 ret
= drm_get_pci_dev(pdev
, pent
, &driver
);
216 nouveau_object_ref(NULL
, (struct nouveau_object
**)&device
);
224 nouveau_drm_load(struct drm_device
*dev
, unsigned long flags
)
226 struct pci_dev
*pdev
= dev
->pdev
;
227 struct nouveau_device
*device
;
228 struct nouveau_drm
*drm
;
231 ret
= nouveau_cli_create(pdev
, 0, sizeof(*drm
), (void**)&drm
);
235 dev
->dev_private
= drm
;
238 INIT_LIST_HEAD(&drm
->clients
);
239 spin_lock_init(&drm
->tile
.lock
);
241 /* make sure AGP controller is in a consistent state before we
242 * (possibly) execute vbios init tables (see nouveau_agp.h)
244 if (drm_pci_device_is_agp(dev
) && dev
->agp
) {
245 /* dummy device object, doesn't init anything, but allows
246 * agp code access to registers
248 ret
= nouveau_object_new(nv_object(drm
), NVDRM_CLIENT
,
249 NVDRM_DEVICE
, 0x0080,
250 &(struct nv_device_class
) {
253 ~(NV_DEVICE_DISABLE_MMIO
|
254 NV_DEVICE_DISABLE_IDENTIFY
),
256 }, sizeof(struct nv_device_class
),
261 nouveau_agp_reset(drm
);
262 nouveau_object_del(nv_object(drm
), NVDRM_CLIENT
, NVDRM_DEVICE
);
265 ret
= nouveau_object_new(nv_object(drm
), NVDRM_CLIENT
, NVDRM_DEVICE
,
266 0x0080, &(struct nv_device_class
) {
270 }, sizeof(struct nv_device_class
),
275 /* workaround an odd issue on nvc1 by disabling the device's
276 * nosnoop capability. hopefully won't cause issues until a
277 * better fix is found - assuming there is one...
279 device
= nv_device(drm
->device
);
280 if (nv_device(drm
->device
)->chipset
== 0xc1)
281 nv_mask(device
, 0x00088080, 0x00000800, 0x00000000);
283 nouveau_vga_init(drm
);
284 nouveau_agp_init(drm
);
286 if (device
->card_type
>= NV_50
) {
287 ret
= nouveau_vm_new(nv_device(drm
->device
), 0, (1ULL << 40),
288 0x1000, &drm
->client
.base
.vm
);
293 ret
= nouveau_ttm_init(drm
);
297 ret
= nouveau_bios_init(dev
);
301 ret
= nouveau_irq_init(dev
);
305 ret
= nouveau_display_create(dev
);
309 if (dev
->mode_config
.num_crtc
) {
310 ret
= nouveau_display_init(dev
);
315 nouveau_pm_init(dev
);
317 nouveau_accel_init(drm
);
318 nouveau_fbcon_init(dev
);
322 nouveau_display_destroy(dev
);
324 nouveau_irq_fini(dev
);
326 nouveau_bios_takedown(dev
);
328 nouveau_ttm_fini(drm
);
330 nouveau_agp_fini(drm
);
331 nouveau_vga_fini(drm
);
333 nouveau_cli_destroy(&drm
->client
);
338 nouveau_drm_unload(struct drm_device
*dev
)
340 struct nouveau_drm
*drm
= nouveau_drm(dev
);
342 nouveau_fbcon_fini(dev
);
343 nouveau_accel_fini(drm
);
345 nouveau_pm_fini(dev
);
347 nouveau_display_fini(dev
);
348 nouveau_display_destroy(dev
);
350 nouveau_irq_fini(dev
);
351 nouveau_bios_takedown(dev
);
353 nouveau_ttm_fini(drm
);
354 nouveau_agp_fini(drm
);
355 nouveau_vga_fini(drm
);
357 nouveau_cli_destroy(&drm
->client
);
362 nouveau_drm_remove(struct pci_dev
*pdev
)
364 struct drm_device
*dev
= pci_get_drvdata(pdev
);
365 struct nouveau_drm
*drm
= nouveau_drm(dev
);
366 struct nouveau_object
*device
;
368 device
= drm
->client
.base
.device
;
371 nouveau_object_ref(NULL
, &device
);
372 nouveau_object_debug();
376 nouveau_drm_suspend(struct pci_dev
*pdev
, pm_message_t pm_state
)
378 struct drm_device
*dev
= pci_get_drvdata(pdev
);
379 struct nouveau_drm
*drm
= nouveau_drm(dev
);
380 struct nouveau_cli
*cli
;
383 if (dev
->switch_power_state
== DRM_SWITCH_POWER_OFF
||
384 pm_state
.event
== PM_EVENT_PRETHAW
)
387 NV_INFO(drm
, "suspending fbcon...\n");
388 nouveau_fbcon_set_suspend(dev
, 1);
390 NV_INFO(drm
, "suspending display...\n");
391 ret
= nouveau_display_suspend(dev
);
395 NV_INFO(drm
, "evicting buffers...\n");
396 ttm_bo_evict_mm(&drm
->ttm
.bdev
, TTM_PL_VRAM
);
398 if (drm
->fence
&& nouveau_fence(drm
)->suspend
) {
399 if (!nouveau_fence(drm
)->suspend(drm
))
403 NV_INFO(drm
, "suspending client object trees...\n");
404 list_for_each_entry(cli
, &drm
->clients
, head
) {
405 ret
= nouveau_client_fini(&cli
->base
, true);
410 ret
= nouveau_client_fini(&drm
->client
.base
, true);
414 nouveau_agp_fini(drm
);
416 pci_save_state(pdev
);
417 if (pm_state
.event
== PM_EVENT_SUSPEND
) {
418 pci_disable_device(pdev
);
419 pci_set_power_state(pdev
, PCI_D3hot
);
425 list_for_each_entry_continue_reverse(cli
, &drm
->clients
, head
) {
426 nouveau_client_init(&cli
->base
);
429 NV_INFO(drm
, "resuming display...\n");
430 nouveau_display_resume(dev
);
435 nouveau_drm_resume(struct pci_dev
*pdev
)
437 struct drm_device
*dev
= pci_get_drvdata(pdev
);
438 struct nouveau_drm
*drm
= nouveau_drm(dev
);
439 struct nouveau_cli
*cli
;
442 if (dev
->switch_power_state
== DRM_SWITCH_POWER_OFF
)
445 NV_INFO(drm
, "re-enabling device...\n");
446 pci_set_power_state(pdev
, PCI_D0
);
447 pci_restore_state(pdev
);
448 ret
= pci_enable_device(pdev
);
451 pci_set_master(pdev
);
453 nouveau_agp_reset(drm
);
455 NV_INFO(drm
, "resuming client object trees...\n");
456 nouveau_client_init(&drm
->client
.base
);
457 nouveau_agp_init(drm
);
459 list_for_each_entry(cli
, &drm
->clients
, head
) {
460 nouveau_client_init(&cli
->base
);
463 if (drm
->fence
&& nouveau_fence(drm
)->resume
)
464 nouveau_fence(drm
)->resume(drm
);
466 nouveau_run_vbios_init(dev
);
467 nouveau_irq_postinstall(dev
);
468 nouveau_pm_resume(dev
);
470 NV_INFO(drm
, "resuming display...\n");
471 nouveau_display_resume(dev
);
476 nouveau_drm_open(struct drm_device
*dev
, struct drm_file
*fpriv
)
478 struct pci_dev
*pdev
= dev
->pdev
;
479 struct nouveau_drm
*drm
= nouveau_drm(dev
);
480 struct nouveau_cli
*cli
;
483 ret
= nouveau_cli_create(pdev
, fpriv
->pid
, sizeof(*cli
), (void **)&cli
);
487 if (nv_device(drm
->device
)->card_type
>= NV_50
) {
488 ret
= nouveau_vm_new(nv_device(drm
->device
), 0, (1ULL << 40),
489 0x1000, &cli
->base
.vm
);
491 nouveau_cli_destroy(cli
);
496 fpriv
->driver_priv
= cli
;
498 mutex_lock(&drm
->client
.mutex
);
499 list_add(&cli
->head
, &drm
->clients
);
500 mutex_unlock(&drm
->client
.mutex
);
505 nouveau_drm_preclose(struct drm_device
*dev
, struct drm_file
*fpriv
)
507 struct nouveau_cli
*cli
= nouveau_cli(fpriv
);
508 struct nouveau_drm
*drm
= nouveau_drm(dev
);
511 nouveau_abi16_fini(cli
->abi16
);
513 mutex_lock(&drm
->client
.mutex
);
514 list_del(&cli
->head
);
515 mutex_unlock(&drm
->client
.mutex
);
519 nouveau_drm_postclose(struct drm_device
*dev
, struct drm_file
*fpriv
)
521 struct nouveau_cli
*cli
= nouveau_cli(fpriv
);
522 nouveau_cli_destroy(cli
);
525 static struct drm_ioctl_desc
527 DRM_IOCTL_DEF_DRV(NOUVEAU_GETPARAM
, nouveau_abi16_ioctl_getparam
, DRM_UNLOCKED
|DRM_AUTH
),
528 DRM_IOCTL_DEF_DRV(NOUVEAU_SETPARAM
, nouveau_abi16_ioctl_setparam
, DRM_UNLOCKED
|DRM_AUTH
|DRM_MASTER
|DRM_ROOT_ONLY
),
529 DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_ALLOC
, nouveau_abi16_ioctl_channel_alloc
, DRM_UNLOCKED
|DRM_AUTH
),
530 DRM_IOCTL_DEF_DRV(NOUVEAU_CHANNEL_FREE
, nouveau_abi16_ioctl_channel_free
, DRM_UNLOCKED
|DRM_AUTH
),
531 DRM_IOCTL_DEF_DRV(NOUVEAU_GROBJ_ALLOC
, nouveau_abi16_ioctl_grobj_alloc
, DRM_UNLOCKED
|DRM_AUTH
),
532 DRM_IOCTL_DEF_DRV(NOUVEAU_NOTIFIEROBJ_ALLOC
, nouveau_abi16_ioctl_notifierobj_alloc
, DRM_UNLOCKED
|DRM_AUTH
),
533 DRM_IOCTL_DEF_DRV(NOUVEAU_GPUOBJ_FREE
, nouveau_abi16_ioctl_gpuobj_free
, DRM_UNLOCKED
|DRM_AUTH
),
534 DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_NEW
, nouveau_gem_ioctl_new
, DRM_UNLOCKED
|DRM_AUTH
),
535 DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_PUSHBUF
, nouveau_gem_ioctl_pushbuf
, DRM_UNLOCKED
|DRM_AUTH
),
536 DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_PREP
, nouveau_gem_ioctl_cpu_prep
, DRM_UNLOCKED
|DRM_AUTH
),
537 DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_CPU_FINI
, nouveau_gem_ioctl_cpu_fini
, DRM_UNLOCKED
|DRM_AUTH
),
538 DRM_IOCTL_DEF_DRV(NOUVEAU_GEM_INFO
, nouveau_gem_ioctl_info
, DRM_UNLOCKED
|DRM_AUTH
),
541 static const struct file_operations
542 nouveau_driver_fops
= {
543 .owner
= THIS_MODULE
,
545 .release
= drm_release
,
546 .unlocked_ioctl
= drm_ioctl
,
547 .mmap
= nouveau_ttm_mmap
,
549 .fasync
= drm_fasync
,
551 #if defined(CONFIG_COMPAT)
552 .compat_ioctl
= nouveau_compat_ioctl
,
554 .llseek
= noop_llseek
,
557 static struct drm_driver
560 DRIVER_USE_AGP
| DRIVER_PCI_DMA
| DRIVER_SG
|
561 DRIVER_HAVE_IRQ
| DRIVER_IRQ_SHARED
| DRIVER_GEM
|
562 DRIVER_MODESET
| DRIVER_PRIME
,
564 .load
= nouveau_drm_load
,
565 .unload
= nouveau_drm_unload
,
566 .open
= nouveau_drm_open
,
567 .preclose
= nouveau_drm_preclose
,
568 .postclose
= nouveau_drm_postclose
,
569 .lastclose
= nouveau_vga_lastclose
,
571 .irq_preinstall
= nouveau_irq_preinstall
,
572 .irq_postinstall
= nouveau_irq_postinstall
,
573 .irq_uninstall
= nouveau_irq_uninstall
,
574 .irq_handler
= nouveau_irq_handler
,
576 .get_vblank_counter
= drm_vblank_count
,
577 .enable_vblank
= nouveau_vblank_enable
,
578 .disable_vblank
= nouveau_vblank_disable
,
580 .ioctls
= nouveau_ioctls
,
581 .fops
= &nouveau_driver_fops
,
583 .prime_handle_to_fd
= drm_gem_prime_handle_to_fd
,
584 .prime_fd_to_handle
= drm_gem_prime_fd_to_handle
,
585 .gem_prime_export
= nouveau_gem_prime_export
,
586 .gem_prime_import
= nouveau_gem_prime_import
,
588 .gem_init_object
= nouveau_gem_object_new
,
589 .gem_free_object
= nouveau_gem_object_del
,
590 .gem_open_object
= nouveau_gem_object_open
,
591 .gem_close_object
= nouveau_gem_object_close
,
593 .dumb_create
= nouveau_display_dumb_create
,
594 .dumb_map_offset
= nouveau_display_dumb_map_offset
,
595 .dumb_destroy
= nouveau_display_dumb_destroy
,
600 .date
= GIT_REVISION
,
604 .major
= DRIVER_MAJOR
,
605 .minor
= DRIVER_MINOR
,
606 .patchlevel
= DRIVER_PATCHLEVEL
,
609 static struct pci_device_id
610 nouveau_drm_pci_table
[] = {
612 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA
, PCI_ANY_ID
),
613 .class = PCI_BASE_CLASS_DISPLAY
<< 16,
614 .class_mask
= 0xff << 16,
617 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA_SGS
, PCI_ANY_ID
),
618 .class = PCI_BASE_CLASS_DISPLAY
<< 16,
619 .class_mask
= 0xff << 16,
624 static struct pci_driver
625 nouveau_drm_pci_driver
= {
627 .id_table
= nouveau_drm_pci_table
,
628 .probe
= nouveau_drm_probe
,
629 .remove
= nouveau_drm_remove
,
630 .suspend
= nouveau_drm_suspend
,
631 .resume
= nouveau_drm_resume
,
635 nouveau_drm_init(void)
637 driver
.num_ioctls
= ARRAY_SIZE(nouveau_ioctls
);
639 if (nouveau_modeset
== -1) {
640 #ifdef CONFIG_VGA_CONSOLE
641 if (vgacon_text_force())
648 if (!nouveau_modeset
)
651 nouveau_register_dsm_handler();
652 return drm_pci_init(&driver
, &nouveau_drm_pci_driver
);
656 nouveau_drm_exit(void)
658 if (!nouveau_modeset
)
661 drm_pci_exit(&driver
, &nouveau_drm_pci_driver
);
662 nouveau_unregister_dsm_handler();
665 module_init(nouveau_drm_init
);
666 module_exit(nouveau_drm_exit
);
668 MODULE_DEVICE_TABLE(pci
, nouveau_drm_pci_table
);
669 MODULE_AUTHOR(DRIVER_AUTHOR
);
670 MODULE_DESCRIPTION(DRIVER_DESC
);
671 MODULE_LICENSE("GPL and additional rights");