renesas/virt/virtio-spec.git - Virtio specification

diff options

author	rusty <rusty@0c8fb4dd-22a2-4bb5-bc14-6c75a5f43652>	2014-02-10 03:00:49 +0000
committer	rusty <rusty@0c8fb4dd-22a2-4bb5-bc14-6c75a5f43652>	2014-02-10 03:00:49 +0000
commit	4bd4aaf8cc48746145c9a5e4b84a8409efdcafb6 (patch)
tree	be73c17179e20f9b162851498ff093061c87559a /REVISION
parent	6590c3b263316ded30ceddcab6ee3b63a3bd7bdb (diff)

ccw: missed field conversions

Signed-off-by: Cornelia Huck <cornelia.huck@de.ibm.com> Signed-off-by: Rusty Russell <rusty@au1.ibm.com> git-svn-id: https://tools.oasis-open.org/version-control/svn/virtio@209 0c8fb4dd-22a2-4bb5-bc14-6c75a5f43652

Diffstat (limited to 'REVISION')

0 files changed, 0 insertions, 0 deletions

/* * Copyright 2005-2006 Stephane Marchesin * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ #include "drmP.h" #include "drm.h" #include "nouveau_drv.h" #include "nouveau_drm.h" /* returns the number of hw fifos */ int nouveau_fifo_number(struct drm_device *dev) { struct drm_nouveau_private *dev_priv=dev->dev_private; switch(dev_priv->card_type) { case NV_04: case NV_05: return 16; case NV_50: return 128; default: return 32; } } /* returns the size of fifo context */ int nouveau_fifo_ctx_size(struct drm_device *dev) { struct drm_nouveau_private *dev_priv=dev->dev_private; if (dev_priv->card_type >= NV_40) return 128; else if (dev_priv->card_type >= NV_17) return 64; else return 32; } /*********************************** * functions doing the actual work ***********************************/ /* voir nv_xaa.c : NVResetGraphics * m�moire mapp�e par nv_driver.c : NVMapMem * voir nv_driver.c : NVPreInit */ static int nouveau_fifo_instmem_configure(struct drm_device *dev) { struct drm_nouveau_private *dev_priv = dev->dev_private; NV_WRITE(NV03_PFIFO_RAMHT, (0x03 << 24) /* search 128 */ | ((dev_priv->ramht_bits - 9) << 16) | (dev_priv->ramht_offset >> 8) ); NV_WRITE(NV03_PFIFO_RAMRO, dev_priv->ramro_offset>>8); switch(dev_priv->card_type) { case NV_50: case NV_40: switch (dev_priv->chipset) { case 0x47: case 0x49: case 0x4b: NV_WRITE(0x2230, 1); break; default: break; } NV_WRITE(NV40_PFIFO_RAMFC, 0x30002); break; case NV_44: NV_WRITE(NV40_PFIFO_RAMFC, ((nouveau_mem_fb_amount(dev)-512*1024+dev_priv->ramfc_offset)>>16) | (2 << 16)); break; case NV_30: case NV_20: case NV_17: NV_WRITE(NV03_PFIFO_RAMFC, (dev_priv->ramfc_offset>>8) | (1 << 16) /* 64 Bytes entry*/); /* XXX nvidia blob set bit 18, 21,23 for nv20 & nv30 */ break; case NV_11: case NV_10: case NV_04: NV_WRITE(NV03_PFIFO_RAMFC, dev_priv->ramfc_offset>>8); break; } return 0; } int nouveau_fifo_init(struct drm_device *dev) { struct drm_nouveau_private *dev_priv = dev->dev_private; int ret; NV_WRITE(NV03_PMC_ENABLE, NV_READ(NV03_PMC_ENABLE) & ~NV_PMC_ENABLE_PFIFO); NV_WRITE(NV03_PMC_ENABLE, NV_READ(NV03_PMC_ENABLE) | NV_PMC_ENABLE_PFIFO); /* Enable PFIFO error reporting */ NV_WRITE(NV03_PFIFO_INTR_0, 0xFFFFFFFF); NV_WRITE(NV03_PFIFO_INTR_EN_0, 0xFFFFFFFF); NV_WRITE(NV03_PFIFO_CACHES, 0x00000000); ret = nouveau_fifo_instmem_configure(dev); if (ret) { DRM_ERROR("Failed to configure instance memory\n"); return ret; } /* FIXME remove all the stuff that's done in nouveau_fifo_alloc */ DRM_DEBUG("Setting defaults for remaining PFIFO regs\n"); /* All channels into PIO mode */ NV_WRITE(NV04_PFIFO_MODE, 0x00000000); NV_WRITE(NV03_PFIFO_CACHE1_PUSH0, 0x00000000); NV_WRITE(NV04_PFIFO_CACHE1_PULL0, 0x00000000); /* Channel 0 active, PIO mode */ NV_WRITE(NV03_PFIFO_CACHE1_PUSH1, 0x00000000); /* PUT and GET to 0 */ NV_WRITE(NV04_PFIFO_CACHE1_DMA_PUT, 0x00000000); NV_WRITE(NV04_PFIFO_CACHE1_DMA_GET, 0x00000000); /* No cmdbuf object */ NV_WRITE(NV04_PFIFO_CACHE1_DMA_INSTANCE, 0x00000000); NV_WRITE(NV03_PFIFO_CACHE0_PUSH0, 0x00000000); NV_WRITE(NV03_PFIFO_CACHE0_PULL0, 0x00000000); NV_WRITE(NV04_PFIFO_SIZE, 0x0000FFFF); NV_WRITE(NV04_PFIFO_CACHE1_HASH, 0x0000FFFF); NV_WRITE(NV04_PFIFO_CACHE0_PULL1, 0x00000001); NV_WRITE(NV04_PFIFO_CACHE1_DMA_CTL, 0x00000000); NV_WRITE(NV04_PFIFO_CACHE1_DMA_STATE, 0x00000000); NV_WRITE(NV04_PFIFO_CACHE1_ENGINE, 0x00000000); NV_WRITE(NV04_PFIFO_CACHE1_DMA_FETCH, NV_PFIFO_CACHE1_DMA_FETCH_TRIG_112_BYTES | NV_PFIFO_CACHE1_DMA_FETCH_SIZE_128_BYTES | NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_4 | #ifdef __BIG_ENDIAN NV_PFIFO_CACHE1_BIG_ENDIAN | #endif 0x00000000); NV_WRITE(NV04_PFIFO_CACHE1_DMA_PUSH, 0x00000001); NV_WRITE(NV03_PFIFO_CACHE1_PUSH0, 0x00000001); NV_WRITE(NV04_PFIFO_CACHE1_PULL0, 0x00000001); NV_WRITE(NV04_PFIFO_CACHE1_PULL1, 0x00000001); /* FIXME on NV04 */ if (dev_priv->card_type >= NV_10) { NV_WRITE(NV10_PGRAPH_CTX_USER, 0x0); NV_WRITE(NV04_PFIFO_DELAY_0, 0xff /* retrycount*/ ); if (dev_priv->card_type >= NV_40) NV_WRITE(NV10_PGRAPH_CTX_CONTROL, 0x00002001); else NV_WRITE(NV10_PGRAPH_CTX_CONTROL, 0x10110000); } else { NV_WRITE(NV04_PGRAPH_CTX_USER, 0x0); NV_WRITE(NV04_PFIFO_DELAY_0, 0xff /* retrycount*/ ); NV_WRITE(NV04_PGRAPH_CTX_CONTROL, 0x10110000); } NV_WRITE(NV04_PFIFO_DMA_TIMESLICE, 0x001fffff); NV_WRITE(NV03_PFIFO_CACHES, 0x00000001); return 0; } static int nouveau_fifo_pushbuf_ctxdma_init(struct nouveau_channel *chan) { struct drm_device *dev = chan->dev; struct drm_nouveau_private *dev_priv = dev->dev_private; struct mem_block *pb = chan->pushbuf_mem; struct nouveau_gpuobj *pushbuf = NULL; int ret; if (pb->flags & NOUVEAU_MEM_AGP) { ret = nouveau_gpuobj_gart_dma_new(chan, pb->start, pb->size, NV_DMA_ACCESS_RO, &pushbuf, &chan->pushbuf_base); } else if (pb->flags & NOUVEAU_MEM_PCI) { ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY, pb->start, pb->size, NV_DMA_ACCESS_RO, NV_DMA_TARGET_PCI_NONLINEAR, &pushbuf); chan->pushbuf_base = 0; } else if (dev_priv->card_type != NV_04) { ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY, pb->start, pb->size, NV_DMA_ACCESS_RO, NV_DMA_TARGET_VIDMEM, &pushbuf); chan->pushbuf_base = 0; } else { /* NV04 cmdbuf hack, from original ddx.. not sure of it's * exact reason for existing :) PCI access to cmdbuf in * VRAM. */ ret = nouveau_gpuobj_dma_new(chan, NV_CLASS_DMA_IN_MEMORY, pb->start + drm_get_resource_start(dev, 1), pb->size, NV_DMA_ACCESS_RO, NV_DMA_TARGET_PCI, &pushbuf); chan->pushbuf_base = 0; } if ((ret = nouveau_gpuobj_ref_add(dev, chan, 0, pushbuf, &chan->pushbuf))) { DRM_ERROR("Error referencing push buffer ctxdma: %d\n", ret); if (pushbuf != dev_priv->gart_info.sg_ctxdma) nouveau_gpuobj_del(dev, &pushbuf); return ret; } return 0; } static struct mem_block * nouveau_fifo_user_pushbuf_alloc(struct drm_device *dev) { struct drm_nouveau_private *dev_priv = dev->dev_private; struct nouveau_config *config = &dev_priv->config; struct mem_block *pb; int pb_min_size = max(NV03_FIFO_SIZE,PAGE_SIZE); /* Defaults for unconfigured values */ if (!config->cmdbuf.location) config->cmdbuf.location = NOUVEAU_MEM_FB; if (!config->cmdbuf.size || config->cmdbuf.size < pb_min_size) config->cmdbuf.size = pb_min_size; pb = nouveau_mem_alloc(dev, 0, config->cmdbuf.size, config->cmdbuf.location | NOUVEAU_MEM_MAPPED, (struct drm_file *)-2); if (!pb) DRM_ERROR("Couldn't allocate DMA push buffer.\n"); return pb; } /* allocates and initializes a fifo for user space consumption */ int nouveau_fifo_alloc(struct drm_device *dev, struct nouveau_channel **chan_ret, struct drm_file *file_priv, struct mem_block *pushbuf, uint32_t vram_handle, uint32_t tt_handle) { int ret; struct drm_nouveau_private *dev_priv = dev->dev_private; struct nouveau_engine *engine = &dev_priv->Engine; struct nouveau_channel *chan; int channel; /* * Alright, here is the full story * Nvidia cards have multiple hw fifo contexts (praise them for that, * no complicated crash-prone context switches) * We allocate a new context for each app and let it write to it directly * (woo, full userspace command submission !) * When there are no more contexts, you lost */ for(channel=0; channel<nouveau_fifo_number(dev); channel++) { if (dev_priv->fifos[channel] == NULL) break; } /* no more fifos. you lost. */ if (channel==nouveau_fifo_number(dev)) return -EINVAL; dev_priv->fifos[channel] = drm_calloc(1, sizeof(struct nouveau_channel), DRM_MEM_DRIVER); if (!dev_priv->fifos[channel]) return -ENOMEM; dev_priv->fifo_alloc_count++; chan = dev_priv->fifos[channel]; chan->dev = dev; chan->id = channel; chan->file_priv = file_priv; chan->pushbuf_mem = pushbuf; DRM_INFO("Allocating FIFO number %d\n", channel); /* Allocate space for per-channel fixed notifier memory */ ret = nouveau_notifier_init_channel(chan); if (ret) { nouveau_fifo_free(chan); return ret; } /* Setup channel's default objects */ ret = nouveau_gpuobj_channel_init(chan, vram_handle, tt_handle); if (ret) { nouveau_fifo_free(chan); return ret; } /* Create a dma object for the push buffer */ ret = nouveau_fifo_pushbuf_ctxdma_init(chan); if (ret) { nouveau_fifo_free(chan); return ret; } nouveau_wait_for_idle(dev); /* disable the fifo caches */ NV_WRITE(NV03_PFIFO_CACHES, 0x00000000); NV_WRITE(NV04_PFIFO_CACHE1_DMA_PUSH, NV_READ(NV04_PFIFO_CACHE1_DMA_PUSH)&(~0x1)); NV_WRITE(NV03_PFIFO_CACHE1_PUSH0, 0x00000000); NV_WRITE(NV04_PFIFO_CACHE1_PULL0, 0x00000000); /* Create a graphics context for new channel */ ret = engine->graph.create_context(chan); if (ret) { nouveau_fifo_free(chan); return ret; } /* Construct inital RAMFC for new channel */ ret = engine->fifo.create_context(chan); if (ret) { nouveau_fifo_free(chan); return ret; } /* setup channel's default get/put values */ if (dev_priv->card_type < NV_50) { NV_WRITE(NV03_FIFO_REGS_DMAPUT(channel), chan->pushbuf_base); NV_WRITE(NV03_FIFO_REGS_DMAGET(channel), chan->pushbuf_base); } else { NV_WRITE(NV50_FIFO_REGS_DMAPUT(channel), chan->pushbuf_base); NV_WRITE(NV50_FIFO_REGS_DMAGET(channel), chan->pushbuf_base); } /* If this is the first channel, setup PFIFO ourselves. For any * other case, the GPU will handle this when it switches contexts. */ if (dev_priv->fifo_alloc_count == 1) { ret = engine->fifo.load_context(chan); if (ret) { nouveau_fifo_free(chan); return ret; } ret = engine->graph.load_context(chan); if (ret) { nouveau_fifo_free(chan); return ret; } } NV_WRITE(NV04_PFIFO_CACHE1_DMA_PUSH, NV_READ(NV04_PFIFO_CACHE1_DMA_PUSH) | 1); NV_WRITE(NV03_PFIFO_CACHE1_PUSH0, 0x00000001); NV_WRITE(NV04_PFIFO_CACHE1_PULL0, 0x00000001); NV_WRITE(NV04_PFIFO_CACHE1_PULL1, 0x00000001); /* reenable the fifo caches */ NV_WRITE(NV03_PFIFO_CACHES, 1); DRM_INFO("%s: initialised FIFO %d\n", __func__, channel); *chan_ret = chan; return 0; } /* stops a fifo */ void nouveau_fifo_free(struct nouveau_channel *chan) { struct drm_device *dev = chan->dev; struct drm_nouveau_private *dev_priv = dev->dev_private; struct nouveau_engine *engine = &dev_priv->Engine; DRM_INFO("%s: freeing fifo %d\n", __func__, chan->id); /* disable the fifo caches */ NV_WRITE(NV03_PFIFO_CACHES, 0x00000000); NV_WRITE(NV04_PFIFO_CACHE1_DMA_PUSH, NV_READ(NV04_PFIFO_CACHE1_DMA_PUSH)&(~0x1)); NV_WRITE(NV03_PFIFO_CACHE1_PUSH0, 0x00000000); NV_WRITE(NV04_PFIFO_CACHE1_PULL0, 0x00000000); /* stop the fifo, otherwise it could be running and * it will crash when removing gpu objects */ if (dev_priv->card_type < NV_50) { NV_WRITE(NV03_FIFO_REGS_DMAPUT(chan->id), chan->pushbuf_base); NV_WRITE(NV03_FIFO_REGS_DMAGET(chan->id), chan->pushbuf_base); } else { NV_WRITE(NV50_FIFO_REGS_DMAPUT(chan->id), chan->pushbuf_base); NV_WRITE(NV50_FIFO_REGS_DMAGET(chan->id), chan->pushbuf_base); } // FIXME XXX needs more code engine->fifo.destroy_context(chan); /* Cleanup PGRAPH state */ engine->graph.destroy_context(chan); /* reenable the fifo caches */ NV_WRITE(NV04_PFIFO_CACHE1_DMA_PUSH, NV_READ(NV04_PFIFO_CACHE1_DMA_PUSH) | 1); NV_WRITE(NV03_PFIFO_CACHE1_PUSH0, 0x00000001); NV_WRITE(NV04_PFIFO_CACHE1_PULL0, 0x00000001); NV_WRITE(NV03_PFIFO_CACHES, 0x00000001); /* Deallocate push buffer */ nouveau_gpuobj_ref_del(dev, &chan->pushbuf); if (chan->pushbuf_mem) { nouveau_mem_free(dev, chan->pushbuf_mem); chan->pushbuf_mem = NULL; } /* Destroy objects belonging to the channel */ nouveau_gpuobj_channel_takedown(chan); nouveau_notifier_takedown_channel(chan); dev_priv->fifos[chan->id] = NULL; dev_priv->fifo_alloc_count--; drm_free(chan, sizeof(*chan), DRM_MEM_DRIVER); } /* cleanups all the fifos from file_priv */ void nouveau_fifo_cleanup(struct drm_device *dev, struct drm_file *file_priv) { struct drm_nouveau_private *dev_priv = dev->dev_private; int i; DRM_DEBUG("clearing FIFO enables from file_priv\n"); for(i = 0; i < nouveau_fifo_number(dev); i++) { struct nouveau_channel *chan = dev_priv->fifos[i]; if (chan && chan->file_priv == file_priv) nouveau_fifo_free(chan); } } int nouveau_fifo_owner(struct drm_device *dev, struct drm_file *file_priv, int channel) { struct drm_nouveau_private *dev_priv = dev->dev_private; if (channel >= nouveau_fifo_number(dev)) return 0; if (dev_priv->fifos[channel] == NULL) return 0; return (dev_priv->fifos[channel]->file_priv == file_priv); } /*********************************** * ioctls wrapping the functions ***********************************/ static int nouveau_ioctl_fifo_alloc(struct drm_device *dev, void *data, struct drm_file *file_priv) { struct drm_nouveau_private *dev_priv = dev->dev_private; struct drm_nouveau_channel_alloc *init = data; struct drm_map_list *entry; struct nouveau_channel *chan; struct mem_block *pushbuf; int res; NOUVEAU_CHECK_INITIALISED_WITH_RETURN; if (init->fb_ctxdma_handle == ~0 || init->tt_ctxdma_handle == ~0) return -EINVAL; pushbuf = nouveau_fifo_user_pushbuf_alloc(dev); if (!pushbuf) return -ENOMEM; res = nouveau_fifo_alloc(dev, &chan, file_priv, pushbuf, init->fb_ctxdma_handle, init->tt_ctxdma_handle); if (res) return res; init->channel = chan->id; init->put_base = chan->pushbuf_base; /* make the fifo available to user space */ /* first, the fifo control regs */ init->ctrl = dev_priv->mmio->offset; if (dev_priv->card_type < NV_50) {


context:
space:
mode: