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.
24 #include <core/object.h>
25 #include <core/client.h>
26 #include <core/device.h>
27 #include <core/class.h>
30 #include "nouveau_drm.h"
31 #include "nouveau_dma.h"
32 #include "nouveau_gem.h"
33 #include "nouveau_chan.h"
34 #include "nouveau_abi16.h"
36 struct nouveau_abi16
*
37 nouveau_abi16_get(struct drm_file
*file_priv
, struct drm_device
*dev
)
39 struct nouveau_cli
*cli
= nouveau_cli(file_priv
);
40 mutex_lock(&cli
->mutex
);
42 struct nouveau_abi16
*abi16
;
43 cli
->abi16
= abi16
= kzalloc(sizeof(*abi16
), GFP_KERNEL
);
45 INIT_LIST_HEAD(&abi16
->channels
);
47 /* allocate device object targeting client's default
48 * device (ie. the one that belongs to the fd it
51 if (nvif_device_init(&cli
->base
.base
, NULL
,
52 NVDRM_DEVICE
, NV_DEVICE_CLASS
,
53 &(struct nv_device_class
) {
55 }, sizeof(struct nv_device_class
),
63 mutex_unlock(&cli
->mutex
);
69 nouveau_abi16_put(struct nouveau_abi16
*abi16
, int ret
)
71 struct nouveau_cli
*cli
= (void *)nvif_client(&abi16
->device
.base
);
72 mutex_unlock(&cli
->mutex
);
77 nouveau_abi16_swclass(struct nouveau_drm
*drm
)
79 switch (drm
->device
.info
.family
) {
80 case NV_DEVICE_INFO_V0_TNT
:
82 case NV_DEVICE_INFO_V0_CELSIUS
:
83 case NV_DEVICE_INFO_V0_KELVIN
:
84 case NV_DEVICE_INFO_V0_RANKINE
:
85 case NV_DEVICE_INFO_V0_CURIE
:
87 case NV_DEVICE_INFO_V0_TESLA
:
89 case NV_DEVICE_INFO_V0_FERMI
:
90 case NV_DEVICE_INFO_V0_KEPLER
:
91 case NV_DEVICE_INFO_V0_MAXWELL
:
99 nouveau_abi16_ntfy_fini(struct nouveau_abi16_chan
*chan
,
100 struct nouveau_abi16_ntfy
*ntfy
)
102 nouveau_mm_free(&chan
->heap
, &ntfy
->node
);
103 list_del(&ntfy
->head
);
108 nouveau_abi16_chan_fini(struct nouveau_abi16
*abi16
,
109 struct nouveau_abi16_chan
*chan
)
111 struct nouveau_abi16_ntfy
*ntfy
, *temp
;
113 /* wait for all activity to stop before releasing notify object, which
114 * may be still in use */
115 if (chan
->chan
&& chan
->ntfy
)
116 nouveau_channel_idle(chan
->chan
);
118 /* cleanup notifier state */
119 list_for_each_entry_safe(ntfy
, temp
, &chan
->notifiers
, head
) {
120 nouveau_abi16_ntfy_fini(chan
, ntfy
);
124 nouveau_bo_vma_del(chan
->ntfy
, &chan
->ntfy_vma
);
125 nouveau_bo_unpin(chan
->ntfy
);
126 drm_gem_object_unreference_unlocked(&chan
->ntfy
->gem
);
129 if (chan
->heap
.block_size
)
130 nouveau_mm_fini(&chan
->heap
);
132 /* destroy channel object, all children will be killed too */
134 abi16
->handles
&= ~(1ULL << (chan
->chan
->object
->handle
& 0xffff));
135 nouveau_channel_del(&chan
->chan
);
138 list_del(&chan
->head
);
143 nouveau_abi16_fini(struct nouveau_abi16
*abi16
)
145 struct nouveau_cli
*cli
= (void *)nvif_client(&abi16
->device
.base
);
146 struct nouveau_abi16_chan
*chan
, *temp
;
148 /* cleanup channels */
149 list_for_each_entry_safe(chan
, temp
, &abi16
->channels
, head
) {
150 nouveau_abi16_chan_fini(abi16
, chan
);
153 /* destroy the device object */
154 nvif_device_fini(&abi16
->device
);
161 nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS
)
163 struct nouveau_cli
*cli
= nouveau_cli(file_priv
);
164 struct nouveau_drm
*drm
= nouveau_drm(dev
);
165 struct nvif_device
*device
= &drm
->device
;
166 struct nouveau_timer
*ptimer
= nvkm_timer(device
);
167 struct nouveau_graph
*graph
= nvkm_gr(device
);
168 struct drm_nouveau_getparam
*getparam
= data
;
170 switch (getparam
->param
) {
171 case NOUVEAU_GETPARAM_CHIPSET_ID
:
172 getparam
->value
= device
->info
.chipset
;
174 case NOUVEAU_GETPARAM_PCI_VENDOR
:
175 if (nv_device_is_pci(nvkm_device(device
)))
176 getparam
->value
= dev
->pdev
->vendor
;
180 case NOUVEAU_GETPARAM_PCI_DEVICE
:
181 if (nv_device_is_pci(nvkm_device(device
)))
182 getparam
->value
= dev
->pdev
->device
;
186 case NOUVEAU_GETPARAM_BUS_TYPE
:
187 if (!nv_device_is_pci(nvkm_device(device
)))
190 if (drm_pci_device_is_agp(dev
))
193 if (!pci_is_pcie(dev
->pdev
))
198 case NOUVEAU_GETPARAM_FB_SIZE
:
199 getparam
->value
= drm
->gem
.vram_available
;
201 case NOUVEAU_GETPARAM_AGP_SIZE
:
202 getparam
->value
= drm
->gem
.gart_available
;
204 case NOUVEAU_GETPARAM_VM_VRAM_BASE
:
205 getparam
->value
= 0; /* deprecated */
207 case NOUVEAU_GETPARAM_PTIMER_TIME
:
208 getparam
->value
= ptimer
->read(ptimer
);
210 case NOUVEAU_GETPARAM_HAS_BO_USAGE
:
213 case NOUVEAU_GETPARAM_HAS_PAGEFLIP
:
216 case NOUVEAU_GETPARAM_GRAPH_UNITS
:
217 getparam
->value
= graph
->units
? graph
->units(graph
) : 0;
220 NV_PRINTK(debug
, cli
, "unknown parameter %lld\n", getparam
->param
);
228 nouveau_abi16_ioctl_setparam(ABI16_IOCTL_ARGS
)
234 nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS
)
236 struct drm_nouveau_channel_alloc
*init
= data
;
237 struct nouveau_cli
*cli
= nouveau_cli(file_priv
);
238 struct nouveau_drm
*drm
= nouveau_drm(dev
);
239 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
240 struct nouveau_abi16_chan
*chan
;
241 struct nvif_device
*device
;
242 struct nouveau_instmem
*imem
;
243 struct nouveau_fb
*pfb
;
246 if (unlikely(!abi16
))
250 return nouveau_abi16_put(abi16
, -ENODEV
);
252 device
= &abi16
->device
;
253 imem
= nvkm_instmem(device
);
254 pfb
= nvkm_fb(device
);
256 /* hack to allow channel engine type specification on kepler */
257 if (device
->info
.family
>= NV_DEVICE_INFO_V0_KEPLER
) {
258 if (init
->fb_ctxdma_handle
!= ~0)
259 init
->fb_ctxdma_handle
= NVE0_CHANNEL_IND_ENGINE_GR
;
261 init
->fb_ctxdma_handle
= init
->tt_ctxdma_handle
;
263 /* allow flips to be executed if this is a graphics channel */
264 init
->tt_ctxdma_handle
= 0;
265 if (init
->fb_ctxdma_handle
== NVE0_CHANNEL_IND_ENGINE_GR
)
266 init
->tt_ctxdma_handle
= 1;
269 if (init
->fb_ctxdma_handle
== ~0 || init
->tt_ctxdma_handle
== ~0)
270 return nouveau_abi16_put(abi16
, -EINVAL
);
272 /* allocate "abi16 channel" data and make up a handle for it */
273 init
->channel
= __ffs64(~abi16
->handles
);
274 if (~abi16
->handles
== 0)
275 return nouveau_abi16_put(abi16
, -ENOSPC
);
277 chan
= kzalloc(sizeof(*chan
), GFP_KERNEL
);
279 return nouveau_abi16_put(abi16
, -ENOMEM
);
281 INIT_LIST_HEAD(&chan
->notifiers
);
282 list_add(&chan
->head
, &abi16
->channels
);
283 abi16
->handles
|= (1ULL << init
->channel
);
285 /* create channel object and initialise dma and fence management */
286 ret
= nouveau_channel_new(drm
, device
, NVDRM_CHAN
| init
->channel
,
287 init
->fb_ctxdma_handle
,
288 init
->tt_ctxdma_handle
, &chan
->chan
);
292 if (device
->info
.family
>= NV_DEVICE_INFO_V0_TESLA
)
293 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_VRAM
|
294 NOUVEAU_GEM_DOMAIN_GART
;
296 if (chan
->chan
->push
.buffer
->bo
.mem
.mem_type
== TTM_PL_VRAM
)
297 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_VRAM
;
299 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_GART
;
301 if (device
->info
.family
< NV_DEVICE_INFO_V0_CELSIUS
) {
302 init
->subchan
[0].handle
= 0x00000000;
303 init
->subchan
[0].grclass
= 0x0000;
304 init
->subchan
[1].handle
= NvSw
;
305 init
->subchan
[1].grclass
= 0x506e;
306 init
->nr_subchan
= 2;
309 /* Named memory object area */
310 ret
= nouveau_gem_new(dev
, PAGE_SIZE
, 0, NOUVEAU_GEM_DOMAIN_GART
,
313 ret
= nouveau_bo_pin(chan
->ntfy
, TTM_PL_FLAG_TT
);
317 if (device
->info
.family
>= NV_DEVICE_INFO_V0_TESLA
) {
318 ret
= nouveau_bo_vma_add(chan
->ntfy
, cli
->vm
,
324 ret
= drm_gem_handle_create(file_priv
, &chan
->ntfy
->gem
,
325 &init
->notifier_handle
);
329 ret
= nouveau_mm_init(&chan
->heap
, 0, PAGE_SIZE
, 1);
332 nouveau_abi16_chan_fini(abi16
, chan
);
333 return nouveau_abi16_put(abi16
, ret
);
338 nouveau_abi16_ioctl_channel_free(ABI16_IOCTL_ARGS
)
340 struct drm_nouveau_channel_free
*req
= data
;
341 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
342 struct nouveau_abi16_chan
*chan
;
345 if (unlikely(!abi16
))
348 list_for_each_entry(chan
, &abi16
->channels
, head
) {
349 if (chan
->chan
->object
->handle
== (NVDRM_CHAN
| req
->channel
)) {
350 nouveau_abi16_chan_fini(abi16
, chan
);
351 return nouveau_abi16_put(abi16
, 0);
355 return nouveau_abi16_put(abi16
, ret
);
359 nouveau_abi16_ioctl_grobj_alloc(ABI16_IOCTL_ARGS
)
361 struct drm_nouveau_grobj_alloc
*init
= data
;
362 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
363 struct nouveau_drm
*drm
= nouveau_drm(dev
);
364 struct nouveau_object
*object
;
367 if (unlikely(!abi16
))
370 if (init
->handle
== ~0)
371 return nouveau_abi16_put(abi16
, -EINVAL
);
373 /* compatibility with userspace that assumes 506e for all chipsets */
374 if (init
->class == 0x506e) {
375 init
->class = nouveau_abi16_swclass(drm
);
376 if (init
->class == 0x906e)
377 return nouveau_abi16_put(abi16
, 0);
381 ret
= nouveau_object_new(nv_object(nvkm_client(&abi16
->device
.base
)),
382 NVDRM_CHAN
| init
->channel
, init
->handle
,
383 init
->class, NULL
, 0, &object
);
384 return nouveau_abi16_put(abi16
, ret
);
388 nouveau_abi16_ioctl_notifierobj_alloc(ABI16_IOCTL_ARGS
)
390 struct drm_nouveau_notifierobj_alloc
*info
= data
;
391 struct nouveau_drm
*drm
= nouveau_drm(dev
);
392 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
393 struct nouveau_abi16_chan
*chan
= NULL
, *temp
;
394 struct nouveau_abi16_ntfy
*ntfy
;
395 struct nvif_device
*device
= &abi16
->device
;
396 struct nouveau_object
*object
;
397 struct nv_dma_class args
= {};
400 if (unlikely(!abi16
))
403 /* completely unnecessary for these chipsets... */
404 if (unlikely(device
->info
.family
>= NV_DEVICE_INFO_V0_FERMI
))
405 return nouveau_abi16_put(abi16
, -EINVAL
);
407 list_for_each_entry(temp
, &abi16
->channels
, head
) {
408 if (temp
->chan
->object
->handle
== (NVDRM_CHAN
| info
->channel
)) {
415 return nouveau_abi16_put(abi16
, -ENOENT
);
417 ntfy
= kzalloc(sizeof(*ntfy
), GFP_KERNEL
);
419 return nouveau_abi16_put(abi16
, -ENOMEM
);
421 list_add(&ntfy
->head
, &chan
->notifiers
);
422 ntfy
->handle
= info
->handle
;
424 ret
= nouveau_mm_head(&chan
->heap
, 1, info
->size
, info
->size
, 1,
429 args
.start
= ntfy
->node
->offset
;
430 args
.limit
= ntfy
->node
->offset
+ ntfy
->node
->length
- 1;
431 if (device
->info
.family
>= NV_DEVICE_INFO_V0_TESLA
) {
432 args
.flags
= NV_DMA_TARGET_VM
| NV_DMA_ACCESS_VM
;
433 args
.start
+= chan
->ntfy_vma
.offset
;
434 args
.limit
+= chan
->ntfy_vma
.offset
;
436 if (drm
->agp
.stat
== ENABLED
) {
437 args
.flags
= NV_DMA_TARGET_AGP
| NV_DMA_ACCESS_RDWR
;
438 args
.start
+= drm
->agp
.base
+ chan
->ntfy
->bo
.offset
;
439 args
.limit
+= drm
->agp
.base
+ chan
->ntfy
->bo
.offset
;
441 args
.flags
= NV_DMA_TARGET_VM
| NV_DMA_ACCESS_RDWR
;
442 args
.start
+= chan
->ntfy
->bo
.offset
;
443 args
.limit
+= chan
->ntfy
->bo
.offset
;
447 ret
= nouveau_object_new(nv_object(nvkm_client(&abi16
->device
.base
)),
448 NVDRM_CHAN
| info
->channel
, ntfy
->handle
,
449 NV_DMA_IN_MEMORY_CLASS
, &args
, sizeof(args
),
454 info
->offset
= ntfy
->node
->offset
;
458 nouveau_abi16_ntfy_fini(chan
, ntfy
);
459 return nouveau_abi16_put(abi16
, ret
);
463 nouveau_abi16_ioctl_gpuobj_free(ABI16_IOCTL_ARGS
)
465 struct drm_nouveau_gpuobj_free
*fini
= data
;
466 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
467 struct nouveau_abi16_chan
*chan
= NULL
, *temp
;
468 struct nouveau_abi16_ntfy
*ntfy
;
471 if (unlikely(!abi16
))
474 list_for_each_entry(temp
, &abi16
->channels
, head
) {
475 if (temp
->chan
->object
->handle
== (NVDRM_CHAN
| fini
->channel
)) {
482 return nouveau_abi16_put(abi16
, -ENOENT
);
484 /* synchronize with the user channel and destroy the gpu object */
485 nouveau_channel_idle(chan
->chan
);
488 ret
= nouveau_object_del(nv_object(nvkm_client(&abi16
->device
.base
)),
489 chan
->chan
->object
->handle
, fini
->handle
);
491 return nouveau_abi16_put(abi16
, ret
);
493 /* cleanup extra state if this object was a notifier */
494 list_for_each_entry(ntfy
, &chan
->notifiers
, head
) {
495 if (ntfy
->handle
== fini
->handle
) {
496 nouveau_mm_free(&chan
->heap
, &ntfy
->node
);
497 list_del(&ntfy
->head
);
502 return nouveau_abi16_put(abi16
, 0);