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 <nvif/client.h>
25 #include <nvif/driver.h>
26 #include <nvif/ioctl.h>
27 #include <nvif/class.h>
28 #include <nvif/cl0002.h>
29 #include <nvif/cla06f.h>
30 #include <nvif/unpack.h>
32 #include "nouveau_drm.h"
33 #include "nouveau_dma.h"
34 #include "nouveau_gem.h"
35 #include "nouveau_chan.h"
36 #include "nouveau_abi16.h"
38 static struct nouveau_abi16
*
39 nouveau_abi16(struct drm_file
*file_priv
)
41 struct nouveau_cli
*cli
= nouveau_cli(file_priv
);
43 struct nouveau_abi16
*abi16
;
44 cli
->abi16
= abi16
= kzalloc(sizeof(*abi16
), GFP_KERNEL
);
46 struct nv_device_v0 args
= {
50 INIT_LIST_HEAD(&abi16
->channels
);
52 /* allocate device object targeting client's default
53 * device (ie. the one that belongs to the fd it
56 if (nvif_device_init(&cli
->base
.object
, 0, NV_DEVICE
,
68 struct nouveau_abi16
*
69 nouveau_abi16_get(struct drm_file
*file_priv
)
71 struct nouveau_cli
*cli
= nouveau_cli(file_priv
);
72 mutex_lock(&cli
->mutex
);
73 if (nouveau_abi16(file_priv
))
75 mutex_unlock(&cli
->mutex
);
80 nouveau_abi16_put(struct nouveau_abi16
*abi16
, int ret
)
82 struct nouveau_cli
*cli
= (void *)abi16
->device
.object
.client
;
83 mutex_unlock(&cli
->mutex
);
88 nouveau_abi16_swclass(struct nouveau_drm
*drm
)
90 switch (drm
->device
.info
.family
) {
91 case NV_DEVICE_INFO_V0_TNT
:
92 return NVIF_CLASS_SW_NV04
;
93 case NV_DEVICE_INFO_V0_CELSIUS
:
94 case NV_DEVICE_INFO_V0_KELVIN
:
95 case NV_DEVICE_INFO_V0_RANKINE
:
96 case NV_DEVICE_INFO_V0_CURIE
:
97 return NVIF_CLASS_SW_NV10
;
98 case NV_DEVICE_INFO_V0_TESLA
:
99 return NVIF_CLASS_SW_NV50
;
100 case NV_DEVICE_INFO_V0_FERMI
:
101 case NV_DEVICE_INFO_V0_KEPLER
:
102 case NV_DEVICE_INFO_V0_MAXWELL
:
103 return NVIF_CLASS_SW_GF100
;
110 nouveau_abi16_ntfy_fini(struct nouveau_abi16_chan
*chan
,
111 struct nouveau_abi16_ntfy
*ntfy
)
113 nvif_object_fini(&ntfy
->object
);
114 nvkm_mm_free(&chan
->heap
, &ntfy
->node
);
115 list_del(&ntfy
->head
);
120 nouveau_abi16_chan_fini(struct nouveau_abi16
*abi16
,
121 struct nouveau_abi16_chan
*chan
)
123 struct nouveau_abi16_ntfy
*ntfy
, *temp
;
125 /* wait for all activity to stop before releasing notify object, which
126 * may be still in use */
127 if (chan
->chan
&& chan
->ntfy
)
128 nouveau_channel_idle(chan
->chan
);
130 /* cleanup notifier state */
131 list_for_each_entry_safe(ntfy
, temp
, &chan
->notifiers
, head
) {
132 nouveau_abi16_ntfy_fini(chan
, ntfy
);
136 nouveau_bo_vma_del(chan
->ntfy
, &chan
->ntfy_vma
);
137 nouveau_bo_unpin(chan
->ntfy
);
138 drm_gem_object_unreference_unlocked(&chan
->ntfy
->gem
);
141 if (chan
->heap
.block_size
)
142 nvkm_mm_fini(&chan
->heap
);
144 /* destroy channel object, all children will be killed too */
146 nouveau_channel_idle(chan
->chan
);
147 nouveau_channel_del(&chan
->chan
);
150 list_del(&chan
->head
);
155 nouveau_abi16_fini(struct nouveau_abi16
*abi16
)
157 struct nouveau_cli
*cli
= (void *)abi16
->device
.object
.client
;
158 struct nouveau_abi16_chan
*chan
, *temp
;
160 /* cleanup channels */
161 list_for_each_entry_safe(chan
, temp
, &abi16
->channels
, head
) {
162 nouveau_abi16_chan_fini(abi16
, chan
);
165 /* destroy the device object */
166 nvif_device_fini(&abi16
->device
);
173 nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS
)
175 struct nouveau_cli
*cli
= nouveau_cli(file_priv
);
176 struct nouveau_drm
*drm
= nouveau_drm(dev
);
177 struct nvif_device
*device
= &drm
->device
;
178 struct nvkm_gr
*gr
= nvxx_gr(device
);
179 struct drm_nouveau_getparam
*getparam
= data
;
181 switch (getparam
->param
) {
182 case NOUVEAU_GETPARAM_CHIPSET_ID
:
183 getparam
->value
= device
->info
.chipset
;
185 case NOUVEAU_GETPARAM_PCI_VENDOR
:
186 if (nvxx_device(device
)->func
->pci
)
187 getparam
->value
= dev
->pdev
->vendor
;
191 case NOUVEAU_GETPARAM_PCI_DEVICE
:
192 if (nvxx_device(device
)->func
->pci
)
193 getparam
->value
= dev
->pdev
->device
;
197 case NOUVEAU_GETPARAM_BUS_TYPE
:
198 if (!nvxx_device(device
)->func
->pci
)
201 if (drm_pci_device_is_agp(dev
))
204 if (!pci_is_pcie(dev
->pdev
))
209 case NOUVEAU_GETPARAM_FB_SIZE
:
210 getparam
->value
= drm
->gem
.vram_available
;
212 case NOUVEAU_GETPARAM_AGP_SIZE
:
213 getparam
->value
= drm
->gem
.gart_available
;
215 case NOUVEAU_GETPARAM_VM_VRAM_BASE
:
216 getparam
->value
= 0; /* deprecated */
218 case NOUVEAU_GETPARAM_PTIMER_TIME
:
219 getparam
->value
= nvif_device_time(device
);
221 case NOUVEAU_GETPARAM_HAS_BO_USAGE
:
224 case NOUVEAU_GETPARAM_HAS_PAGEFLIP
:
227 case NOUVEAU_GETPARAM_GRAPH_UNITS
:
228 getparam
->value
= nvkm_gr_units(gr
);
231 NV_PRINTK(dbg
, cli
, "unknown parameter %lld\n", getparam
->param
);
239 nouveau_abi16_ioctl_setparam(ABI16_IOCTL_ARGS
)
245 nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS
)
247 struct drm_nouveau_channel_alloc
*init
= data
;
248 struct nouveau_cli
*cli
= nouveau_cli(file_priv
);
249 struct nouveau_drm
*drm
= nouveau_drm(dev
);
250 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
);
251 struct nouveau_abi16_chan
*chan
;
252 struct nvif_device
*device
;
255 if (unlikely(!abi16
))
259 return nouveau_abi16_put(abi16
, -ENODEV
);
261 device
= &abi16
->device
;
263 /* hack to allow channel engine type specification on kepler */
264 if (device
->info
.family
>= NV_DEVICE_INFO_V0_KEPLER
) {
265 if (init
->fb_ctxdma_handle
!= ~0)
266 init
->fb_ctxdma_handle
= KEPLER_CHANNEL_GPFIFO_A_V0_ENGINE_GR
;
268 init
->fb_ctxdma_handle
= init
->tt_ctxdma_handle
;
270 /* allow flips to be executed if this is a graphics channel */
271 init
->tt_ctxdma_handle
= 0;
272 if (init
->fb_ctxdma_handle
== KEPLER_CHANNEL_GPFIFO_A_V0_ENGINE_GR
)
273 init
->tt_ctxdma_handle
= 1;
276 if (init
->fb_ctxdma_handle
== ~0 || init
->tt_ctxdma_handle
== ~0)
277 return nouveau_abi16_put(abi16
, -EINVAL
);
279 /* allocate "abi16 channel" data and make up a handle for it */
280 chan
= kzalloc(sizeof(*chan
), GFP_KERNEL
);
282 return nouveau_abi16_put(abi16
, -ENOMEM
);
284 INIT_LIST_HEAD(&chan
->notifiers
);
285 list_add(&chan
->head
, &abi16
->channels
);
287 /* create channel object and initialise dma and fence management */
288 ret
= nouveau_channel_new(drm
, device
, init
->fb_ctxdma_handle
,
289 init
->tt_ctxdma_handle
, &chan
->chan
);
293 init
->channel
= chan
->chan
->chid
;
295 if (device
->info
.family
>= NV_DEVICE_INFO_V0_TESLA
)
296 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_VRAM
|
297 NOUVEAU_GEM_DOMAIN_GART
;
299 if (chan
->chan
->push
.buffer
->bo
.mem
.mem_type
== TTM_PL_VRAM
)
300 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_VRAM
;
302 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_GART
;
304 if (device
->info
.family
< NV_DEVICE_INFO_V0_CELSIUS
) {
305 init
->subchan
[0].handle
= 0x00000000;
306 init
->subchan
[0].grclass
= 0x0000;
307 init
->subchan
[1].handle
= chan
->chan
->nvsw
.handle
;
308 init
->subchan
[1].grclass
= 0x506e;
309 init
->nr_subchan
= 2;
312 /* Named memory object area */
313 ret
= nouveau_gem_new(dev
, PAGE_SIZE
, 0, NOUVEAU_GEM_DOMAIN_GART
,
316 ret
= nouveau_bo_pin(chan
->ntfy
, TTM_PL_FLAG_TT
, false);
320 if (device
->info
.family
>= NV_DEVICE_INFO_V0_TESLA
) {
321 ret
= nouveau_bo_vma_add(chan
->ntfy
, cli
->vm
,
327 ret
= drm_gem_handle_create(file_priv
, &chan
->ntfy
->gem
,
328 &init
->notifier_handle
);
332 ret
= nvkm_mm_init(&chan
->heap
, 0, PAGE_SIZE
, 1);
335 nouveau_abi16_chan_fini(abi16
, chan
);
336 return nouveau_abi16_put(abi16
, ret
);
339 static struct nouveau_abi16_chan
*
340 nouveau_abi16_chan(struct nouveau_abi16
*abi16
, int channel
)
342 struct nouveau_abi16_chan
*chan
;
344 list_for_each_entry(chan
, &abi16
->channels
, head
) {
345 if (chan
->chan
->chid
== channel
)
353 nouveau_abi16_usif(struct drm_file
*file_priv
, void *data
, u32 size
)
356 struct nvif_ioctl_v0 v0
;
358 struct nouveau_abi16_chan
*chan
;
359 struct nouveau_abi16
*abi16
;
362 if (!(ret
= nvif_unpack(ret
, &data
, &size
, args
->v0
, 0, 0, true))) {
363 switch (args
->v0
.type
) {
364 case NVIF_IOCTL_V0_NEW
:
365 case NVIF_IOCTL_V0_MTHD
:
366 case NVIF_IOCTL_V0_SCLASS
:
374 if (!(abi16
= nouveau_abi16(file_priv
)))
377 if (args
->v0
.token
!= ~0ULL) {
378 if (!(chan
= nouveau_abi16_chan(abi16
, args
->v0
.token
)))
380 args
->v0
.object
= nvif_handle(&chan
->chan
->user
);
381 args
->v0
.owner
= NVIF_IOCTL_V0_OWNER_ANY
;
385 args
->v0
.object
= nvif_handle(&abi16
->device
.object
);
386 args
->v0
.owner
= NVIF_IOCTL_V0_OWNER_ANY
;
391 nouveau_abi16_ioctl_channel_free(ABI16_IOCTL_ARGS
)
393 struct drm_nouveau_channel_free
*req
= data
;
394 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
);
395 struct nouveau_abi16_chan
*chan
;
397 if (unlikely(!abi16
))
400 chan
= nouveau_abi16_chan(abi16
, req
->channel
);
402 return nouveau_abi16_put(abi16
, -ENOENT
);
403 nouveau_abi16_chan_fini(abi16
, chan
);
404 return nouveau_abi16_put(abi16
, 0);
408 nouveau_abi16_ioctl_grobj_alloc(ABI16_IOCTL_ARGS
)
410 struct drm_nouveau_grobj_alloc
*init
= data
;
411 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
);
412 struct nouveau_abi16_chan
*chan
;
413 struct nouveau_abi16_ntfy
*ntfy
;
414 struct nvif_client
*client
;
415 struct nvif_sclass
*sclass
;
419 if (unlikely(!abi16
))
422 if (init
->handle
== ~0)
423 return nouveau_abi16_put(abi16
, -EINVAL
);
424 client
= abi16
->device
.object
.client
;
426 chan
= nouveau_abi16_chan(abi16
, init
->channel
);
428 return nouveau_abi16_put(abi16
, -ENOENT
);
430 ret
= nvif_object_sclass_get(&chan
->chan
->user
, &sclass
);
432 return nouveau_abi16_put(abi16
, ret
);
434 if ((init
->class & 0x00ff) == 0x006e) {
435 /* nvsw: compatibility with older 0x*6e class identifier */
436 for (i
= 0; !oclass
&& i
< ret
; i
++) {
437 switch (sclass
[i
].oclass
) {
438 case NVIF_CLASS_SW_NV04
:
439 case NVIF_CLASS_SW_NV10
:
440 case NVIF_CLASS_SW_NV50
:
441 case NVIF_CLASS_SW_GF100
:
442 oclass
= sclass
[i
].oclass
;
449 if ((init
->class & 0x00ff) == 0x00b1) {
450 /* msvld: compatibility with incorrect version exposure */
451 for (i
= 0; i
< ret
; i
++) {
452 if ((sclass
[i
].oclass
& 0x00ff) == 0x00b1) {
453 oclass
= sclass
[i
].oclass
;
458 if ((init
->class & 0x00ff) == 0x00b2) { /* mspdec */
459 /* mspdec: compatibility with incorrect version exposure */
460 for (i
= 0; i
< ret
; i
++) {
461 if ((sclass
[i
].oclass
& 0x00ff) == 0x00b2) {
462 oclass
= sclass
[i
].oclass
;
467 if ((init
->class & 0x00ff) == 0x00b3) { /* msppp */
468 /* msppp: compatibility with incorrect version exposure */
469 for (i
= 0; i
< ret
; i
++) {
470 if ((sclass
[i
].oclass
& 0x00ff) == 0x00b3) {
471 oclass
= sclass
[i
].oclass
;
476 oclass
= init
->class;
479 nvif_object_sclass_put(&sclass
);
481 return nouveau_abi16_put(abi16
, -EINVAL
);
483 ntfy
= kzalloc(sizeof(*ntfy
), GFP_KERNEL
);
485 return nouveau_abi16_put(abi16
, -ENOMEM
);
487 list_add(&ntfy
->head
, &chan
->notifiers
);
489 client
->route
= NVDRM_OBJECT_ABI16
;
490 ret
= nvif_object_init(&chan
->chan
->user
, init
->handle
, oclass
,
491 NULL
, 0, &ntfy
->object
);
492 client
->route
= NVDRM_OBJECT_NVIF
;
495 nouveau_abi16_ntfy_fini(chan
, ntfy
);
496 return nouveau_abi16_put(abi16
, ret
);
500 nouveau_abi16_ioctl_notifierobj_alloc(ABI16_IOCTL_ARGS
)
502 struct drm_nouveau_notifierobj_alloc
*info
= data
;
503 struct nouveau_drm
*drm
= nouveau_drm(dev
);
504 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
);
505 struct nouveau_abi16_chan
*chan
;
506 struct nouveau_abi16_ntfy
*ntfy
;
507 struct nvif_device
*device
= &abi16
->device
;
508 struct nvif_client
*client
;
509 struct nv_dma_v0 args
= {};
512 if (unlikely(!abi16
))
515 /* completely unnecessary for these chipsets... */
516 if (unlikely(device
->info
.family
>= NV_DEVICE_INFO_V0_FERMI
))
517 return nouveau_abi16_put(abi16
, -EINVAL
);
518 client
= abi16
->device
.object
.client
;
520 chan
= nouveau_abi16_chan(abi16
, info
->channel
);
522 return nouveau_abi16_put(abi16
, -ENOENT
);
524 ntfy
= kzalloc(sizeof(*ntfy
), GFP_KERNEL
);
526 return nouveau_abi16_put(abi16
, -ENOMEM
);
528 list_add(&ntfy
->head
, &chan
->notifiers
);
530 ret
= nvkm_mm_head(&chan
->heap
, 0, 1, info
->size
, info
->size
, 1,
535 args
.start
= ntfy
->node
->offset
;
536 args
.limit
= ntfy
->node
->offset
+ ntfy
->node
->length
- 1;
537 if (device
->info
.family
>= NV_DEVICE_INFO_V0_TESLA
) {
538 args
.target
= NV_DMA_V0_TARGET_VM
;
539 args
.access
= NV_DMA_V0_ACCESS_VM
;
540 args
.start
+= chan
->ntfy_vma
.offset
;
541 args
.limit
+= chan
->ntfy_vma
.offset
;
543 if (drm
->agp
.bridge
) {
544 args
.target
= NV_DMA_V0_TARGET_AGP
;
545 args
.access
= NV_DMA_V0_ACCESS_RDWR
;
546 args
.start
+= drm
->agp
.base
+ chan
->ntfy
->bo
.offset
;
547 args
.limit
+= drm
->agp
.base
+ chan
->ntfy
->bo
.offset
;
549 args
.target
= NV_DMA_V0_TARGET_VM
;
550 args
.access
= NV_DMA_V0_ACCESS_RDWR
;
551 args
.start
+= chan
->ntfy
->bo
.offset
;
552 args
.limit
+= chan
->ntfy
->bo
.offset
;
555 client
->route
= NVDRM_OBJECT_ABI16
;
556 client
->super
= true;
557 ret
= nvif_object_init(&chan
->chan
->user
, info
->handle
,
558 NV_DMA_IN_MEMORY
, &args
, sizeof(args
),
560 client
->super
= false;
561 client
->route
= NVDRM_OBJECT_NVIF
;
565 info
->offset
= ntfy
->node
->offset
;
568 nouveau_abi16_ntfy_fini(chan
, ntfy
);
569 return nouveau_abi16_put(abi16
, ret
);
573 nouveau_abi16_ioctl_gpuobj_free(ABI16_IOCTL_ARGS
)
575 struct drm_nouveau_gpuobj_free
*fini
= data
;
576 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
);
577 struct nouveau_abi16_chan
*chan
;
578 struct nouveau_abi16_ntfy
*ntfy
;
581 if (unlikely(!abi16
))
584 chan
= nouveau_abi16_chan(abi16
, fini
->channel
);
586 return nouveau_abi16_put(abi16
, -EINVAL
);
588 /* synchronize with the user channel and destroy the gpu object */
589 nouveau_channel_idle(chan
->chan
);
591 list_for_each_entry(ntfy
, &chan
->notifiers
, head
) {
592 if (ntfy
->object
.handle
== fini
->handle
) {
593 nouveau_abi16_ntfy_fini(chan
, ntfy
);
599 return nouveau_abi16_put(abi16
, ret
);