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 <subdev/fb.h>
31 #include <subdev/timer.h>
32 #include <subdev/instmem.h>
34 #include "nouveau_drm.h"
35 #include "nouveau_dma.h"
36 #include "nouveau_gem.h"
37 #include "nouveau_chan.h"
38 #include "nouveau_abi16.h"
40 struct nouveau_abi16
*
41 nouveau_abi16_get(struct drm_file
*file_priv
, struct drm_device
*dev
)
43 struct nouveau_cli
*cli
= nouveau_cli(file_priv
);
44 mutex_lock(&cli
->mutex
);
46 struct nouveau_abi16
*abi16
;
47 cli
->abi16
= abi16
= kzalloc(sizeof(*abi16
), GFP_KERNEL
);
49 INIT_LIST_HEAD(&abi16
->channels
);
50 abi16
->client
= nv_object(cli
);
52 /* allocate device object targeting client's default
53 * device (ie. the one that belongs to the fd it
56 if (nouveau_object_new(abi16
->client
, NVDRM_CLIENT
,
58 &(struct nv_device_class
) {
61 sizeof(struct nv_device_class
),
69 mutex_unlock(&cli
->mutex
);
75 nouveau_abi16_put(struct nouveau_abi16
*abi16
, int ret
)
77 struct nouveau_cli
*cli
= (void *)abi16
->client
;
78 mutex_unlock(&cli
->mutex
);
83 nouveau_abi16_swclass(struct nouveau_drm
*drm
)
85 switch (nv_device(drm
->device
)->card_type
) {
105 nouveau_abi16_ntfy_fini(struct nouveau_abi16_chan
*chan
,
106 struct nouveau_abi16_ntfy
*ntfy
)
108 nouveau_mm_free(&chan
->heap
, &ntfy
->node
);
109 list_del(&ntfy
->head
);
114 nouveau_abi16_chan_fini(struct nouveau_abi16
*abi16
,
115 struct nouveau_abi16_chan
*chan
)
117 struct nouveau_abi16_ntfy
*ntfy
, *temp
;
119 /* wait for all activity to stop before releasing notify object, which
120 * may be still in use */
121 if (chan
->chan
&& chan
->ntfy
)
122 nouveau_channel_idle(chan
->chan
);
124 /* cleanup notifier state */
125 list_for_each_entry_safe(ntfy
, temp
, &chan
->notifiers
, head
) {
126 nouveau_abi16_ntfy_fini(chan
, ntfy
);
130 nouveau_bo_vma_del(chan
->ntfy
, &chan
->ntfy_vma
);
131 drm_gem_object_unreference_unlocked(chan
->ntfy
->gem
);
134 if (chan
->heap
.block_size
)
135 nouveau_mm_fini(&chan
->heap
);
137 /* destroy channel object, all children will be killed too */
139 abi16
->handles
&= ~(1 << (chan
->chan
->handle
& 0xffff));
140 nouveau_channel_del(&chan
->chan
);
143 list_del(&chan
->head
);
148 nouveau_abi16_fini(struct nouveau_abi16
*abi16
)
150 struct nouveau_cli
*cli
= (void *)abi16
->client
;
151 struct nouveau_abi16_chan
*chan
, *temp
;
153 /* cleanup channels */
154 list_for_each_entry_safe(chan
, temp
, &abi16
->channels
, head
) {
155 nouveau_abi16_chan_fini(abi16
, chan
);
158 /* destroy the device object */
159 nouveau_object_del(abi16
->client
, NVDRM_CLIENT
, NVDRM_DEVICE
);
166 nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS
)
168 struct nouveau_drm
*drm
= nouveau_drm(dev
);
169 struct nouveau_device
*device
= nv_device(drm
->device
);
170 struct nouveau_timer
*ptimer
= nouveau_timer(device
);
171 struct drm_nouveau_getparam
*getparam
= data
;
173 switch (getparam
->param
) {
174 case NOUVEAU_GETPARAM_CHIPSET_ID
:
175 getparam
->value
= device
->chipset
;
177 case NOUVEAU_GETPARAM_PCI_VENDOR
:
178 getparam
->value
= dev
->pci_vendor
;
180 case NOUVEAU_GETPARAM_PCI_DEVICE
:
181 getparam
->value
= dev
->pci_device
;
183 case NOUVEAU_GETPARAM_BUS_TYPE
:
184 if (drm_pci_device_is_agp(dev
))
187 if (!pci_is_pcie(dev
->pdev
))
192 case NOUVEAU_GETPARAM_FB_SIZE
:
193 getparam
->value
= drm
->gem
.vram_available
;
195 case NOUVEAU_GETPARAM_AGP_SIZE
:
196 getparam
->value
= drm
->gem
.gart_available
;
198 case NOUVEAU_GETPARAM_VM_VRAM_BASE
:
199 getparam
->value
= 0; /* deprecated */
201 case NOUVEAU_GETPARAM_PTIMER_TIME
:
202 getparam
->value
= ptimer
->read(ptimer
);
204 case NOUVEAU_GETPARAM_HAS_BO_USAGE
:
207 case NOUVEAU_GETPARAM_HAS_PAGEFLIP
:
210 case NOUVEAU_GETPARAM_GRAPH_UNITS
:
211 /* NV40 and NV50 versions are quite different, but register
212 * address is the same. User is supposed to know the card
213 * family anyway... */
214 if (device
->chipset
>= 0x40) {
215 getparam
->value
= nv_rd32(device
, 0x001540);
220 nv_debug(device
, "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 nouveau_client
*client
;
242 struct nouveau_device
*device
;
243 struct nouveau_instmem
*imem
;
244 struct nouveau_fb
*pfb
;
247 if (unlikely(!abi16
))
251 return nouveau_abi16_put(abi16
, -ENODEV
);
253 client
= nv_client(abi16
->client
);
254 device
= nv_device(abi16
->device
);
255 imem
= nouveau_instmem(device
);
256 pfb
= nouveau_fb(device
);
258 /* hack to allow channel engine type specification on kepler */
259 if (device
->card_type
>= NV_E0
) {
260 if (init
->fb_ctxdma_handle
!= ~0)
261 init
->fb_ctxdma_handle
= NVE0_CHANNEL_IND_ENGINE_GR
;
263 init
->fb_ctxdma_handle
= init
->tt_ctxdma_handle
;
265 /* allow flips to be executed if this is a graphics channel */
266 init
->tt_ctxdma_handle
= 0;
267 if (init
->fb_ctxdma_handle
== NVE0_CHANNEL_IND_ENGINE_GR
)
268 init
->tt_ctxdma_handle
= 1;
271 if (init
->fb_ctxdma_handle
== ~0 || init
->tt_ctxdma_handle
== ~0)
272 return nouveau_abi16_put(abi16
, -EINVAL
);
274 /* allocate "abi16 channel" data and make up a handle for it */
275 init
->channel
= ffsll(~abi16
->handles
);
276 if (!init
->channel
--)
277 return nouveau_abi16_put(abi16
, -ENOSPC
);
279 chan
= kzalloc(sizeof(*chan
), GFP_KERNEL
);
281 return nouveau_abi16_put(abi16
, -ENOMEM
);
283 INIT_LIST_HEAD(&chan
->notifiers
);
284 list_add(&chan
->head
, &abi16
->channels
);
285 abi16
->handles
|= (1 << init
->channel
);
287 /* create channel object and initialise dma and fence management */
288 ret
= nouveau_channel_new(drm
, cli
, NVDRM_DEVICE
, NVDRM_CHAN
|
289 init
->channel
, init
->fb_ctxdma_handle
,
290 init
->tt_ctxdma_handle
, &chan
->chan
);
294 if (device
->card_type
>= NV_50
)
295 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_VRAM
|
296 NOUVEAU_GEM_DOMAIN_GART
;
298 if (chan
->chan
->push
.buffer
->bo
.mem
.mem_type
== TTM_PL_VRAM
)
299 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_VRAM
;
301 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_GART
;
303 if (device
->card_type
< NV_C0
) {
304 init
->subchan
[0].handle
= 0x00000000;
305 init
->subchan
[0].grclass
= 0x0000;
306 init
->subchan
[1].handle
= NvSw
;
307 init
->subchan
[1].grclass
= 0x506e;
308 init
->nr_subchan
= 2;
311 /* Named memory object area */
312 ret
= nouveau_gem_new(dev
, PAGE_SIZE
, 0, NOUVEAU_GEM_DOMAIN_GART
,
315 ret
= nouveau_bo_pin(chan
->ntfy
, TTM_PL_FLAG_TT
);
319 if (device
->card_type
>= NV_50
) {
320 ret
= nouveau_bo_vma_add(chan
->ntfy
, client
->vm
,
326 ret
= drm_gem_handle_create(file_priv
, chan
->ntfy
->gem
,
327 &init
->notifier_handle
);
331 ret
= nouveau_mm_init(&chan
->heap
, 0, PAGE_SIZE
, 1);
334 nouveau_abi16_chan_fini(abi16
, chan
);
335 return nouveau_abi16_put(abi16
, ret
);
340 nouveau_abi16_ioctl_channel_free(ABI16_IOCTL_ARGS
)
342 struct drm_nouveau_channel_free
*req
= data
;
343 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
344 struct nouveau_abi16_chan
*chan
;
347 if (unlikely(!abi16
))
350 list_for_each_entry(chan
, &abi16
->channels
, head
) {
351 if (chan
->chan
->handle
== (NVDRM_CHAN
| req
->channel
)) {
352 nouveau_abi16_chan_fini(abi16
, chan
);
353 return nouveau_abi16_put(abi16
, 0);
357 return nouveau_abi16_put(abi16
, ret
);
361 nouveau_abi16_ioctl_grobj_alloc(ABI16_IOCTL_ARGS
)
363 struct drm_nouveau_grobj_alloc
*init
= data
;
364 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
365 struct nouveau_drm
*drm
= nouveau_drm(dev
);
366 struct nouveau_object
*object
;
369 if (unlikely(!abi16
))
372 if (init
->handle
== ~0)
373 return nouveau_abi16_put(abi16
, -EINVAL
);
375 /* compatibility with userspace that assumes 506e for all chipsets */
376 if (init
->class == 0x506e) {
377 init
->class = nouveau_abi16_swclass(drm
);
378 if (init
->class == 0x906e)
379 return nouveau_abi16_put(abi16
, 0);
382 ret
= nouveau_object_new(abi16
->client
, NVDRM_CHAN
| init
->channel
,
383 init
->handle
, 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_device
*device
= nv_device(drm
->device
);
393 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
394 struct nouveau_abi16_chan
*chan
, *temp
;
395 struct nouveau_abi16_ntfy
*ntfy
;
396 struct nouveau_object
*object
;
397 struct nv_dma_class args
= {};
400 if (unlikely(!abi16
))
403 /* completely unnecessary for these chipsets... */
404 if (unlikely(nv_device(abi16
->device
)->card_type
>= NV_C0
))
405 return nouveau_abi16_put(abi16
, -EINVAL
);
407 list_for_each_entry_safe(chan
, temp
, &abi16
->channels
, head
) {
408 if (chan
->chan
->handle
== (NVDRM_CHAN
| info
->channel
))
414 return nouveau_abi16_put(abi16
, -ENOENT
);
416 ntfy
= kzalloc(sizeof(*ntfy
), GFP_KERNEL
);
418 return nouveau_abi16_put(abi16
, -ENOMEM
);
420 list_add(&ntfy
->head
, &chan
->notifiers
);
421 ntfy
->handle
= info
->handle
;
423 ret
= nouveau_mm_head(&chan
->heap
, 1, info
->size
, info
->size
, 1,
428 args
.start
= ntfy
->node
->offset
;
429 args
.limit
= ntfy
->node
->offset
+ ntfy
->node
->length
- 1;
430 if (device
->card_type
>= NV_50
) {
431 args
.flags
= NV_DMA_TARGET_VM
| NV_DMA_ACCESS_VM
;
432 args
.start
+= chan
->ntfy_vma
.offset
;
433 args
.limit
+= chan
->ntfy_vma
.offset
;
435 if (drm
->agp
.stat
== ENABLED
) {
436 args
.flags
= NV_DMA_TARGET_AGP
| NV_DMA_ACCESS_RDWR
;
437 args
.start
+= drm
->agp
.base
+ chan
->ntfy
->bo
.offset
;
438 args
.limit
+= drm
->agp
.base
+ chan
->ntfy
->bo
.offset
;
440 args
.flags
= NV_DMA_TARGET_VM
| NV_DMA_ACCESS_RDWR
;
441 args
.start
+= chan
->ntfy
->bo
.offset
;
442 args
.limit
+= chan
->ntfy
->bo
.offset
;
445 ret
= nouveau_object_new(abi16
->client
, chan
->chan
->handle
,
446 ntfy
->handle
, 0x003d, &args
,
447 sizeof(args
), &object
);
453 nouveau_abi16_ntfy_fini(chan
, ntfy
);
454 return nouveau_abi16_put(abi16
, ret
);
458 nouveau_abi16_ioctl_gpuobj_free(ABI16_IOCTL_ARGS
)
460 struct drm_nouveau_gpuobj_free
*fini
= data
;
461 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
462 struct nouveau_abi16_chan
*chan
, *temp
;
463 struct nouveau_abi16_ntfy
*ntfy
;
466 if (unlikely(!abi16
))
469 list_for_each_entry_safe(chan
, temp
, &abi16
->channels
, head
) {
470 if (chan
->chan
->handle
== (NVDRM_CHAN
| fini
->channel
))
476 return nouveau_abi16_put(abi16
, -ENOENT
);
478 /* synchronize with the user channel and destroy the gpu object */
479 nouveau_channel_idle(chan
->chan
);
481 ret
= nouveau_object_del(abi16
->client
, chan
->chan
->handle
, fini
->handle
);
483 return nouveau_abi16_put(abi16
, ret
);
485 /* cleanup extra state if this object was a notifier */
486 list_for_each_entry(ntfy
, &chan
->notifiers
, head
) {
487 if (ntfy
->handle
== fini
->handle
) {
488 nouveau_mm_free(&chan
->heap
, &ntfy
->node
);
489 list_del(&ntfy
->head
);
494 return nouveau_abi16_put(abi16
, 0);