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>
29 #include "nouveau_drm.h"
30 #include "nouveau_dma.h"
31 #include "nouveau_gem.h"
32 #include "nouveau_chan.h"
33 #include "nouveau_abi16.h"
35 struct nouveau_abi16 *
36 nouveau_abi16_get(struct drm_file *file_priv, struct drm_device *dev)
38 struct nouveau_cli *cli = nouveau_cli(file_priv);
39 mutex_lock(&cli->mutex);
41 struct nouveau_abi16 *abi16;
42 cli->abi16 = abi16 = kzalloc(sizeof(*abi16), GFP_KERNEL);
44 struct nv_device_v0 args = {
48 INIT_LIST_HEAD(&abi16->channels);
50 /* allocate device object targeting client's default
51 * device (ie. the one that belongs to the fd it
54 if (nvif_device_init(&cli->base.base, NULL,
55 NOUVEAU_ABI16_DEVICE, NV_DEVICE,
64 mutex_unlock(&cli->mutex);
70 nouveau_abi16_put(struct nouveau_abi16 *abi16, int ret)
72 struct nouveau_cli *cli = (void *)nvif_client(&abi16->device.base);
73 mutex_unlock(&cli->mutex);
78 nouveau_abi16_swclass(struct nouveau_drm *drm)
80 switch (drm->device.info.family) {
81 case NV_DEVICE_INFO_V0_TNT:
83 case NV_DEVICE_INFO_V0_CELSIUS:
84 case NV_DEVICE_INFO_V0_KELVIN:
85 case NV_DEVICE_INFO_V0_RANKINE:
86 case NV_DEVICE_INFO_V0_CURIE:
88 case NV_DEVICE_INFO_V0_TESLA:
90 case NV_DEVICE_INFO_V0_FERMI:
91 case NV_DEVICE_INFO_V0_KEPLER:
92 case NV_DEVICE_INFO_V0_MAXWELL:
100 nouveau_abi16_ntfy_fini(struct nouveau_abi16_chan *chan,
101 struct nouveau_abi16_ntfy *ntfy)
103 nvkm_mm_free(&chan->heap, &ntfy->node);
104 list_del(&ntfy->head);
109 nouveau_abi16_chan_fini(struct nouveau_abi16 *abi16,
110 struct nouveau_abi16_chan *chan)
112 struct nouveau_abi16_ntfy *ntfy, *temp;
114 /* wait for all activity to stop before releasing notify object, which
115 * may be still in use */
116 if (chan->chan && chan->ntfy)
117 nouveau_channel_idle(chan->chan);
119 /* cleanup notifier state */
120 list_for_each_entry_safe(ntfy, temp, &chan->notifiers, head) {
121 nouveau_abi16_ntfy_fini(chan, ntfy);
125 nouveau_bo_vma_del(chan->ntfy, &chan->ntfy_vma);
126 nouveau_bo_unpin(chan->ntfy);
127 drm_gem_object_unreference_unlocked(&chan->ntfy->gem);
130 if (chan->heap.block_size)
131 nvkm_mm_fini(&chan->heap);
133 /* destroy channel object, all children will be killed too */
135 abi16->handles &= ~(1ULL << (chan->chan->object->handle & 0xffff));
136 nouveau_channel_del(&chan->chan);
139 list_del(&chan->head);
144 nouveau_abi16_fini(struct nouveau_abi16 *abi16)
146 struct nouveau_cli *cli = (void *)nvif_client(&abi16->device.base);
147 struct nouveau_abi16_chan *chan, *temp;
149 /* cleanup channels */
150 list_for_each_entry_safe(chan, temp, &abi16->channels, head) {
151 nouveau_abi16_chan_fini(abi16, chan);
154 /* destroy the device object */
155 nvif_device_fini(&abi16->device);
162 nouveau_abi16_ioctl_getparam(ABI16_IOCTL_ARGS)
164 struct nouveau_cli *cli = nouveau_cli(file_priv);
165 struct nouveau_drm *drm = nouveau_drm(dev);
166 struct nvif_device *device = &drm->device;
167 struct nvkm_gr *gr = nvxx_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(nvxx_device(device)))
176 getparam->value = dev->pdev->vendor;
180 case NOUVEAU_GETPARAM_PCI_DEVICE:
181 if (nv_device_is_pci(nvxx_device(device)))
182 getparam->value = dev->pdev->device;
186 case NOUVEAU_GETPARAM_BUS_TYPE:
187 if (!nv_device_is_pci(nvxx_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 = nvif_device_time(device);
210 case NOUVEAU_GETPARAM_HAS_BO_USAGE:
213 case NOUVEAU_GETPARAM_HAS_PAGEFLIP:
216 case NOUVEAU_GETPARAM_GRAPH_UNITS:
217 getparam->value = gr->units ? gr->units(gr) : 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;
244 if (unlikely(!abi16))
248 return nouveau_abi16_put(abi16, -ENODEV);
250 device = &abi16->device;
252 /* hack to allow channel engine type specification on kepler */
253 if (device->info.family >= NV_DEVICE_INFO_V0_KEPLER) {
254 if (init->fb_ctxdma_handle != ~0)
255 init->fb_ctxdma_handle = KEPLER_CHANNEL_GPFIFO_A_V0_ENGINE_GR;
257 init->fb_ctxdma_handle = init->tt_ctxdma_handle;
259 /* allow flips to be executed if this is a graphics channel */
260 init->tt_ctxdma_handle = 0;
261 if (init->fb_ctxdma_handle == KEPLER_CHANNEL_GPFIFO_A_V0_ENGINE_GR)
262 init->tt_ctxdma_handle = 1;
265 if (init->fb_ctxdma_handle == ~0 || init->tt_ctxdma_handle == ~0)
266 return nouveau_abi16_put(abi16, -EINVAL);
268 /* allocate "abi16 channel" data and make up a handle for it */
269 init->channel = __ffs64(~abi16->handles);
270 if (~abi16->handles == 0)
271 return nouveau_abi16_put(abi16, -ENOSPC);
273 chan = kzalloc(sizeof(*chan), GFP_KERNEL);
275 return nouveau_abi16_put(abi16, -ENOMEM);
277 INIT_LIST_HEAD(&chan->notifiers);
278 list_add(&chan->head, &abi16->channels);
279 abi16->handles |= (1ULL << init->channel);
281 /* create channel object and initialise dma and fence management */
282 ret = nouveau_channel_new(drm, device,
283 NOUVEAU_ABI16_CHAN(init->channel),
284 init->fb_ctxdma_handle,
285 init->tt_ctxdma_handle, &chan->chan);
289 if (device->info.family >= NV_DEVICE_INFO_V0_TESLA)
290 init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_VRAM |
291 NOUVEAU_GEM_DOMAIN_GART;
293 if (chan->chan->push.buffer->bo.mem.mem_type == TTM_PL_VRAM)
294 init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_VRAM;
296 init->pushbuf_domains = NOUVEAU_GEM_DOMAIN_GART;
298 if (device->info.family < NV_DEVICE_INFO_V0_CELSIUS) {
299 init->subchan[0].handle = 0x00000000;
300 init->subchan[0].grclass = 0x0000;
301 init->subchan[1].handle = chan->chan->nvsw.handle;
302 init->subchan[1].grclass = 0x506e;
303 init->nr_subchan = 2;
306 /* Named memory object area */
307 ret = nouveau_gem_new(dev, PAGE_SIZE, 0, NOUVEAU_GEM_DOMAIN_GART,
310 ret = nouveau_bo_pin(chan->ntfy, TTM_PL_FLAG_TT, false);
314 if (device->info.family >= NV_DEVICE_INFO_V0_TESLA) {
315 ret = nouveau_bo_vma_add(chan->ntfy, cli->vm,
321 ret = drm_gem_handle_create(file_priv, &chan->ntfy->gem,
322 &init->notifier_handle);
326 ret = nvkm_mm_init(&chan->heap, 0, PAGE_SIZE, 1);
329 nouveau_abi16_chan_fini(abi16, chan);
330 return nouveau_abi16_put(abi16, ret);
333 static struct nouveau_abi16_chan *
334 nouveau_abi16_chan(struct nouveau_abi16 *abi16, int channel)
336 struct nouveau_abi16_chan *chan;
338 list_for_each_entry(chan, &abi16->channels, head) {
339 if (chan->chan->object->handle == NOUVEAU_ABI16_CHAN(channel))
347 nouveau_abi16_ioctl_channel_free(ABI16_IOCTL_ARGS)
349 struct drm_nouveau_channel_free *req = data;
350 struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
351 struct nouveau_abi16_chan *chan;
353 if (unlikely(!abi16))
356 chan = nouveau_abi16_chan(abi16, req->channel);
358 return nouveau_abi16_put(abi16, -ENOENT);
359 nouveau_abi16_chan_fini(abi16, chan);
360 return nouveau_abi16_put(abi16, 0);
364 nouveau_abi16_ioctl_grobj_alloc(ABI16_IOCTL_ARGS)
366 struct drm_nouveau_grobj_alloc *init = data;
368 struct nvif_ioctl_v0 ioctl;
369 struct nvif_ioctl_new_v0 new;
371 .ioctl.owner = NVIF_IOCTL_V0_OWNER_ANY,
372 .ioctl.type = NVIF_IOCTL_V0_NEW,
374 .ioctl.path[2] = NOUVEAU_ABI16_CLIENT,
375 .ioctl.path[1] = NOUVEAU_ABI16_DEVICE,
376 .ioctl.path[0] = NOUVEAU_ABI16_CHAN(init->channel),
377 .new.route = NVDRM_OBJECT_ABI16,
378 .new.handle = init->handle,
379 .new.oclass = init->class,
381 struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
382 struct nouveau_drm *drm = nouveau_drm(dev);
383 struct nvif_client *client;
386 if (unlikely(!abi16))
389 if (init->handle == ~0)
390 return nouveau_abi16_put(abi16, -EINVAL);
391 client = nvif_client(nvif_object(&abi16->device));
393 /* compatibility with userspace that assumes 506e for all chipsets */
394 if (init->class == 0x506e) {
395 init->class = nouveau_abi16_swclass(drm);
396 if (init->class == 0x906e)
397 return nouveau_abi16_put(abi16, 0);
400 ret = nvif_client_ioctl(client, &args, sizeof(args));
401 return nouveau_abi16_put(abi16, ret);
405 nouveau_abi16_ioctl_notifierobj_alloc(ABI16_IOCTL_ARGS)
407 struct drm_nouveau_notifierobj_alloc *info = data;
409 struct nvif_ioctl_v0 ioctl;
410 struct nvif_ioctl_new_v0 new;
411 struct nv_dma_v0 ctxdma;
413 .ioctl.owner = NVIF_IOCTL_V0_OWNER_ANY,
414 .ioctl.type = NVIF_IOCTL_V0_NEW,
416 .ioctl.path[2] = NOUVEAU_ABI16_CLIENT,
417 .ioctl.path[1] = NOUVEAU_ABI16_DEVICE,
418 .ioctl.path[0] = NOUVEAU_ABI16_CHAN(info->channel),
419 .new.route = NVDRM_OBJECT_ABI16,
420 .new.handle = info->handle,
421 .new.oclass = NV_DMA_IN_MEMORY,
423 struct nouveau_drm *drm = nouveau_drm(dev);
424 struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
425 struct nouveau_abi16_chan *chan;
426 struct nouveau_abi16_ntfy *ntfy;
427 struct nvif_device *device = &abi16->device;
428 struct nvif_client *client;
431 if (unlikely(!abi16))
434 /* completely unnecessary for these chipsets... */
435 if (unlikely(device->info.family >= NV_DEVICE_INFO_V0_FERMI))
436 return nouveau_abi16_put(abi16, -EINVAL);
437 client = nvif_client(nvif_object(&abi16->device));
439 chan = nouveau_abi16_chan(abi16, info->channel);
441 return nouveau_abi16_put(abi16, -ENOENT);
443 ntfy = kzalloc(sizeof(*ntfy), GFP_KERNEL);
445 return nouveau_abi16_put(abi16, -ENOMEM);
447 list_add(&ntfy->head, &chan->notifiers);
448 ntfy->handle = info->handle;
450 ret = nvkm_mm_head(&chan->heap, 0, 1, info->size, info->size, 1,
455 args.ctxdma.start = ntfy->node->offset;
456 args.ctxdma.limit = ntfy->node->offset + ntfy->node->length - 1;
457 if (device->info.family >= NV_DEVICE_INFO_V0_TESLA) {
458 args.ctxdma.target = NV_DMA_V0_TARGET_VM;
459 args.ctxdma.access = NV_DMA_V0_ACCESS_VM;
460 args.ctxdma.start += chan->ntfy_vma.offset;
461 args.ctxdma.limit += chan->ntfy_vma.offset;
463 if (drm->agp.stat == ENABLED) {
464 args.ctxdma.target = NV_DMA_V0_TARGET_AGP;
465 args.ctxdma.access = NV_DMA_V0_ACCESS_RDWR;
466 args.ctxdma.start += drm->agp.base + chan->ntfy->bo.offset;
467 args.ctxdma.limit += drm->agp.base + chan->ntfy->bo.offset;
468 client->super = true;
470 args.ctxdma.target = NV_DMA_V0_TARGET_VM;
471 args.ctxdma.access = NV_DMA_V0_ACCESS_RDWR;
472 args.ctxdma.start += chan->ntfy->bo.offset;
473 args.ctxdma.limit += chan->ntfy->bo.offset;
476 ret = nvif_client_ioctl(client, &args, sizeof(args));
477 client->super = false;
481 info->offset = ntfy->node->offset;
485 nouveau_abi16_ntfy_fini(chan, ntfy);
486 return nouveau_abi16_put(abi16, ret);
490 nouveau_abi16_ioctl_gpuobj_free(ABI16_IOCTL_ARGS)
492 struct drm_nouveau_gpuobj_free *fini = data;
494 struct nvif_ioctl_v0 ioctl;
495 struct nvif_ioctl_del del;
497 .ioctl.owner = NVDRM_OBJECT_ABI16,
498 .ioctl.type = NVIF_IOCTL_V0_DEL,
500 .ioctl.path[3] = NOUVEAU_ABI16_CLIENT,
501 .ioctl.path[2] = NOUVEAU_ABI16_DEVICE,
502 .ioctl.path[1] = NOUVEAU_ABI16_CHAN(fini->channel),
503 .ioctl.path[0] = fini->handle,
505 struct nouveau_abi16 *abi16 = nouveau_abi16_get(file_priv, dev);
506 struct nouveau_abi16_chan *chan;
507 struct nouveau_abi16_ntfy *ntfy;
508 struct nvif_client *client;
511 if (unlikely(!abi16))
514 chan = nouveau_abi16_chan(abi16, fini->channel);
516 return nouveau_abi16_put(abi16, -ENOENT);
517 client = nvif_client(nvif_object(&abi16->device));
519 /* synchronize with the user channel and destroy the gpu object */
520 nouveau_channel_idle(chan->chan);
522 ret = nvif_client_ioctl(client, &args, sizeof(args));
524 return nouveau_abi16_put(abi16, ret);
526 /* cleanup extra state if this object was a notifier */
527 list_for_each_entry(ntfy, &chan->notifiers, head) {
528 if (ntfy->handle == fini->handle) {
529 nvkm_mm_free(&chan->heap, &ntfy->node);
530 list_del(&ntfy->head);
535 return nouveau_abi16_put(abi16, 0);