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>
33 #include <engine/graph.h>
35 #include "nouveau_drm.h"
36 #include "nouveau_dma.h"
37 #include "nouveau_gem.h"
38 #include "nouveau_chan.h"
39 #include "nouveau_abi16.h"
41 struct nouveau_abi16
*
42 nouveau_abi16_get(struct drm_file
*file_priv
, struct drm_device
*dev
)
44 struct nouveau_cli
*cli
= nouveau_cli(file_priv
);
45 mutex_lock(&cli
->mutex
);
47 struct nouveau_abi16
*abi16
;
48 cli
->abi16
= abi16
= kzalloc(sizeof(*abi16
), GFP_KERNEL
);
50 INIT_LIST_HEAD(&abi16
->channels
);
51 abi16
->client
= nv_object(cli
);
53 /* allocate device object targeting client's default
54 * device (ie. the one that belongs to the fd it
57 if (nouveau_object_new(abi16
->client
, NVDRM_CLIENT
,
59 &(struct nv_device_class
) {
62 sizeof(struct nv_device_class
),
70 mutex_unlock(&cli
->mutex
);
76 nouveau_abi16_put(struct nouveau_abi16
*abi16
, int ret
)
78 struct nouveau_cli
*cli
= (void *)abi16
->client
;
79 mutex_unlock(&cli
->mutex
);
84 nouveau_abi16_swclass(struct nouveau_drm
*drm
)
86 switch (nv_device(drm
->device
)->card_type
) {
106 nouveau_abi16_ntfy_fini(struct nouveau_abi16_chan
*chan
,
107 struct nouveau_abi16_ntfy
*ntfy
)
109 nouveau_mm_free(&chan
->heap
, &ntfy
->node
);
110 list_del(&ntfy
->head
);
115 nouveau_abi16_chan_fini(struct nouveau_abi16
*abi16
,
116 struct nouveau_abi16_chan
*chan
)
118 struct nouveau_abi16_ntfy
*ntfy
, *temp
;
120 /* wait for all activity to stop before releasing notify object, which
121 * may be still in use */
122 if (chan
->chan
&& chan
->ntfy
)
123 nouveau_channel_idle(chan
->chan
);
125 /* cleanup notifier state */
126 list_for_each_entry_safe(ntfy
, temp
, &chan
->notifiers
, head
) {
127 nouveau_abi16_ntfy_fini(chan
, ntfy
);
131 nouveau_bo_vma_del(chan
->ntfy
, &chan
->ntfy_vma
);
132 drm_gem_object_unreference_unlocked(chan
->ntfy
->gem
);
135 if (chan
->heap
.block_size
)
136 nouveau_mm_fini(&chan
->heap
);
138 /* destroy channel object, all children will be killed too */
140 abi16
->handles
&= ~(1 << (chan
->chan
->handle
& 0xffff));
141 nouveau_channel_del(&chan
->chan
);
144 list_del(&chan
->head
);
149 nouveau_abi16_fini(struct nouveau_abi16
*abi16
)
151 struct nouveau_cli
*cli
= (void *)abi16
->client
;
152 struct nouveau_abi16_chan
*chan
, *temp
;
154 /* cleanup channels */
155 list_for_each_entry_safe(chan
, temp
, &abi16
->channels
, head
) {
156 nouveau_abi16_chan_fini(abi16
, chan
);
159 /* destroy the device object */
160 nouveau_object_del(abi16
->client
, NVDRM_CLIENT
, NVDRM_DEVICE
);
167 nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS
)
169 struct nouveau_drm
*drm
= nouveau_drm(dev
);
170 struct nouveau_device
*device
= nv_device(drm
->device
);
171 struct nouveau_timer
*ptimer
= nouveau_timer(device
);
172 struct nouveau_graph
*graph
= (void *)nouveau_engine(device
, NVDEV_ENGINE_GR
);
173 struct drm_nouveau_getparam
*getparam
= data
;
175 switch (getparam
->param
) {
176 case NOUVEAU_GETPARAM_CHIPSET_ID
:
177 getparam
->value
= device
->chipset
;
179 case NOUVEAU_GETPARAM_PCI_VENDOR
:
180 getparam
->value
= dev
->pci_vendor
;
182 case NOUVEAU_GETPARAM_PCI_DEVICE
:
183 getparam
->value
= dev
->pci_device
;
185 case NOUVEAU_GETPARAM_BUS_TYPE
:
186 if (drm_pci_device_is_agp(dev
))
189 if (!pci_is_pcie(dev
->pdev
))
194 case NOUVEAU_GETPARAM_FB_SIZE
:
195 getparam
->value
= drm
->gem
.vram_available
;
197 case NOUVEAU_GETPARAM_AGP_SIZE
:
198 getparam
->value
= drm
->gem
.gart_available
;
200 case NOUVEAU_GETPARAM_VM_VRAM_BASE
:
201 getparam
->value
= 0; /* deprecated */
203 case NOUVEAU_GETPARAM_PTIMER_TIME
:
204 getparam
->value
= ptimer
->read(ptimer
);
206 case NOUVEAU_GETPARAM_HAS_BO_USAGE
:
209 case NOUVEAU_GETPARAM_HAS_PAGEFLIP
:
212 case NOUVEAU_GETPARAM_GRAPH_UNITS
:
213 getparam
->value
= graph
->units
? graph
->units(graph
) : 0;
216 nv_debug(device
, "unknown parameter %lld\n", getparam
->param
);
224 nouveau_abi16_ioctl_setparam(ABI16_IOCTL_ARGS
)
230 nouveau_abi16_ioctl_channel_alloc(ABI16_IOCTL_ARGS
)
232 struct drm_nouveau_channel_alloc
*init
= data
;
233 struct nouveau_cli
*cli
= nouveau_cli(file_priv
);
234 struct nouveau_drm
*drm
= nouveau_drm(dev
);
235 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
236 struct nouveau_abi16_chan
*chan
;
237 struct nouveau_client
*client
;
238 struct nouveau_device
*device
;
239 struct nouveau_instmem
*imem
;
240 struct nouveau_fb
*pfb
;
243 if (unlikely(!abi16
))
247 return nouveau_abi16_put(abi16
, -ENODEV
);
249 client
= nv_client(abi16
->client
);
250 device
= nv_device(abi16
->device
);
251 imem
= nouveau_instmem(device
);
252 pfb
= nouveau_fb(device
);
254 /* hack to allow channel engine type specification on kepler */
255 if (device
->card_type
>= NV_E0
) {
256 if (init
->fb_ctxdma_handle
!= ~0)
257 init
->fb_ctxdma_handle
= NVE0_CHANNEL_IND_ENGINE_GR
;
259 init
->fb_ctxdma_handle
= init
->tt_ctxdma_handle
;
261 /* allow flips to be executed if this is a graphics channel */
262 init
->tt_ctxdma_handle
= 0;
263 if (init
->fb_ctxdma_handle
== NVE0_CHANNEL_IND_ENGINE_GR
)
264 init
->tt_ctxdma_handle
= 1;
267 if (init
->fb_ctxdma_handle
== ~0 || init
->tt_ctxdma_handle
== ~0)
268 return nouveau_abi16_put(abi16
, -EINVAL
);
270 /* allocate "abi16 channel" data and make up a handle for it */
271 init
->channel
= ffsll(~abi16
->handles
);
272 if (!init
->channel
--)
273 return nouveau_abi16_put(abi16
, -ENOSPC
);
275 chan
= kzalloc(sizeof(*chan
), GFP_KERNEL
);
277 return nouveau_abi16_put(abi16
, -ENOMEM
);
279 INIT_LIST_HEAD(&chan
->notifiers
);
280 list_add(&chan
->head
, &abi16
->channels
);
281 abi16
->handles
|= (1 << init
->channel
);
283 /* create channel object and initialise dma and fence management */
284 ret
= nouveau_channel_new(drm
, cli
, NVDRM_DEVICE
, NVDRM_CHAN
|
285 init
->channel
, init
->fb_ctxdma_handle
,
286 init
->tt_ctxdma_handle
, &chan
->chan
);
290 if (device
->card_type
>= NV_50
)
291 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_VRAM
|
292 NOUVEAU_GEM_DOMAIN_GART
;
294 if (chan
->chan
->push
.buffer
->bo
.mem
.mem_type
== TTM_PL_VRAM
)
295 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_VRAM
;
297 init
->pushbuf_domains
= NOUVEAU_GEM_DOMAIN_GART
;
299 if (device
->card_type
< NV_C0
) {
300 init
->subchan
[0].handle
= 0x00000000;
301 init
->subchan
[0].grclass
= 0x0000;
302 init
->subchan
[1].handle
= NvSw
;
303 init
->subchan
[1].grclass
= 0x506e;
304 init
->nr_subchan
= 2;
307 /* Named memory object area */
308 ret
= nouveau_gem_new(dev
, PAGE_SIZE
, 0, NOUVEAU_GEM_DOMAIN_GART
,
311 ret
= nouveau_bo_pin(chan
->ntfy
, TTM_PL_FLAG_TT
);
315 if (device
->card_type
>= NV_50
) {
316 ret
= nouveau_bo_vma_add(chan
->ntfy
, client
->vm
,
322 ret
= drm_gem_handle_create(file_priv
, chan
->ntfy
->gem
,
323 &init
->notifier_handle
);
327 ret
= nouveau_mm_init(&chan
->heap
, 0, PAGE_SIZE
, 1);
330 nouveau_abi16_chan_fini(abi16
, chan
);
331 return nouveau_abi16_put(abi16
, ret
);
336 nouveau_abi16_ioctl_channel_free(ABI16_IOCTL_ARGS
)
338 struct drm_nouveau_channel_free
*req
= data
;
339 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
340 struct nouveau_abi16_chan
*chan
;
343 if (unlikely(!abi16
))
346 list_for_each_entry(chan
, &abi16
->channels
, head
) {
347 if (chan
->chan
->handle
== (NVDRM_CHAN
| req
->channel
)) {
348 nouveau_abi16_chan_fini(abi16
, chan
);
349 return nouveau_abi16_put(abi16
, 0);
353 return nouveau_abi16_put(abi16
, ret
);
357 nouveau_abi16_ioctl_grobj_alloc(ABI16_IOCTL_ARGS
)
359 struct drm_nouveau_grobj_alloc
*init
= data
;
360 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
361 struct nouveau_drm
*drm
= nouveau_drm(dev
);
362 struct nouveau_object
*object
;
365 if (unlikely(!abi16
))
368 if (init
->handle
== ~0)
369 return nouveau_abi16_put(abi16
, -EINVAL
);
371 /* compatibility with userspace that assumes 506e for all chipsets */
372 if (init
->class == 0x506e) {
373 init
->class = nouveau_abi16_swclass(drm
);
374 if (init
->class == 0x906e)
375 return nouveau_abi16_put(abi16
, 0);
378 ret
= nouveau_object_new(abi16
->client
, NVDRM_CHAN
| init
->channel
,
379 init
->handle
, init
->class, NULL
, 0, &object
);
380 return nouveau_abi16_put(abi16
, ret
);
384 nouveau_abi16_ioctl_notifierobj_alloc(ABI16_IOCTL_ARGS
)
386 struct drm_nouveau_notifierobj_alloc
*info
= data
;
387 struct nouveau_drm
*drm
= nouveau_drm(dev
);
388 struct nouveau_device
*device
= nv_device(drm
->device
);
389 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
390 struct nouveau_abi16_chan
*chan
= NULL
, *temp
;
391 struct nouveau_abi16_ntfy
*ntfy
;
392 struct nouveau_object
*object
;
393 struct nv_dma_class args
= {};
396 if (unlikely(!abi16
))
399 /* completely unnecessary for these chipsets... */
400 if (unlikely(nv_device(abi16
->device
)->card_type
>= NV_C0
))
401 return nouveau_abi16_put(abi16
, -EINVAL
);
403 list_for_each_entry(temp
, &abi16
->channels
, head
) {
404 if (temp
->chan
->handle
== (NVDRM_CHAN
| info
->channel
)) {
411 return nouveau_abi16_put(abi16
, -ENOENT
);
413 ntfy
= kzalloc(sizeof(*ntfy
), GFP_KERNEL
);
415 return nouveau_abi16_put(abi16
, -ENOMEM
);
417 list_add(&ntfy
->head
, &chan
->notifiers
);
418 ntfy
->handle
= info
->handle
;
420 ret
= nouveau_mm_head(&chan
->heap
, 1, info
->size
, info
->size
, 1,
425 args
.start
= ntfy
->node
->offset
;
426 args
.limit
= ntfy
->node
->offset
+ ntfy
->node
->length
- 1;
427 if (device
->card_type
>= NV_50
) {
428 args
.flags
= NV_DMA_TARGET_VM
| NV_DMA_ACCESS_VM
;
429 args
.start
+= chan
->ntfy_vma
.offset
;
430 args
.limit
+= chan
->ntfy_vma
.offset
;
432 if (drm
->agp
.stat
== ENABLED
) {
433 args
.flags
= NV_DMA_TARGET_AGP
| NV_DMA_ACCESS_RDWR
;
434 args
.start
+= drm
->agp
.base
+ chan
->ntfy
->bo
.offset
;
435 args
.limit
+= drm
->agp
.base
+ chan
->ntfy
->bo
.offset
;
437 args
.flags
= NV_DMA_TARGET_VM
| NV_DMA_ACCESS_RDWR
;
438 args
.start
+= chan
->ntfy
->bo
.offset
;
439 args
.limit
+= chan
->ntfy
->bo
.offset
;
442 ret
= nouveau_object_new(abi16
->client
, chan
->chan
->handle
,
443 ntfy
->handle
, 0x003d, &args
,
444 sizeof(args
), &object
);
450 nouveau_abi16_ntfy_fini(chan
, ntfy
);
451 return nouveau_abi16_put(abi16
, ret
);
455 nouveau_abi16_ioctl_gpuobj_free(ABI16_IOCTL_ARGS
)
457 struct drm_nouveau_gpuobj_free
*fini
= data
;
458 struct nouveau_abi16
*abi16
= nouveau_abi16_get(file_priv
, dev
);
459 struct nouveau_abi16_chan
*chan
= NULL
, *temp
;
460 struct nouveau_abi16_ntfy
*ntfy
;
463 if (unlikely(!abi16
))
466 list_for_each_entry(temp
, &abi16
->channels
, head
) {
467 if (temp
->chan
->handle
== (NVDRM_CHAN
| fini
->channel
)) {
474 return nouveau_abi16_put(abi16
, -ENOENT
);
476 /* synchronize with the user channel and destroy the gpu object */
477 nouveau_channel_idle(chan
->chan
);
479 ret
= nouveau_object_del(abi16
->client
, chan
->chan
->handle
, fini
->handle
);
481 return nouveau_abi16_put(abi16
, ret
);
483 /* cleanup extra state if this object was a notifier */
484 list_for_each_entry(ntfy
, &chan
->notifiers
, head
) {
485 if (ntfy
->handle
== fini
->handle
) {
486 nouveau_mm_free(&chan
->heap
, &ntfy
->node
);
487 list_del(&ntfy
->head
);
492 return nouveau_abi16_put(abi16
, 0);