| /************************************************************************** |
| * |
| * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA. |
| * 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, sub license, 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 NON-INFRINGEMENT. IN NO EVENT SHALL |
| * THE COPYRIGHT HOLDERS, AUTHORS 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. |
| * |
| * |
| **************************************************************************/ |
| |
| /* |
| * Authors: |
| * Thomas Hellström <thomas-at-tungstengraphics-dot-com> |
| */ |
| |
| #include "drmP.h" |
| #include "sis_drm.h" |
| #include "sis_drv.h" |
| |
| #include <video/sisfb.h> |
| |
| #define VIDEO_TYPE 0 |
| #define AGP_TYPE 1 |
| |
| |
| #if defined(CONFIG_FB_SIS) || defined(CONFIG_FB_SIS_MODULE) |
| /* fb management via fb device */ |
| |
| #define SIS_MM_ALIGN_SHIFT 0 |
| #define SIS_MM_ALIGN_MASK 0 |
| |
| static void *sis_sman_mm_allocate(void *private, unsigned long size, |
| unsigned alignment) |
| { |
| struct sis_memreq req; |
| |
| req.size = size; |
| sis_malloc(&req); |
| if (req.size == 0) |
| return NULL; |
| else |
| return (void *)(unsigned long)~req.offset; |
| } |
| |
| static void sis_sman_mm_free(void *private, void *ref) |
| { |
| sis_free(~((unsigned long)ref)); |
| } |
| |
| static void sis_sman_mm_destroy(void *private) |
| { |
| ; |
| } |
| |
| static unsigned long sis_sman_mm_offset(void *private, void *ref) |
| { |
| return ~((unsigned long)ref); |
| } |
| |
| #else /* CONFIG_FB_SIS[_MODULE] */ |
| |
| #define SIS_MM_ALIGN_SHIFT 4 |
| #define SIS_MM_ALIGN_MASK ((1 << SIS_MM_ALIGN_SHIFT) - 1) |
| |
| #endif /* CONFIG_FB_SIS[_MODULE] */ |
| |
| static int sis_fb_init(struct drm_device *dev, void *data, struct drm_file *file_priv) |
| { |
| drm_sis_private_t *dev_priv = dev->dev_private; |
| drm_sis_fb_t *fb = data; |
| int ret; |
| |
| mutex_lock(&dev->struct_mutex); |
| #if defined(CONFIG_FB_SIS) || defined(CONFIG_FB_SIS_MODULE) |
| { |
| struct drm_sman_mm sman_mm; |
| sman_mm.private = (void *)0xFFFFFFFF; |
| sman_mm.allocate = sis_sman_mm_allocate; |
| sman_mm.free = sis_sman_mm_free; |
| sman_mm.destroy = sis_sman_mm_destroy; |
| sman_mm.offset = sis_sman_mm_offset; |
| ret = |
| drm_sman_set_manager(&dev_priv->sman, VIDEO_TYPE, &sman_mm); |
| } |
| #else |
| ret = drm_sman_set_range(&dev_priv->sman, VIDEO_TYPE, 0, |
| fb->size >> SIS_MM_ALIGN_SHIFT); |
| #endif |
| |
| if (ret) { |
| DRM_ERROR("VRAM memory manager initialisation error\n"); |
| mutex_unlock(&dev->struct_mutex); |
| return ret; |
| } |
| |
| dev_priv->vram_initialized = 1; |
| dev_priv->vram_offset = fb->offset; |
| |
| mutex_unlock(&dev->struct_mutex); |
| DRM_DEBUG("offset = %u, size = %u\n", fb->offset, fb->size); |
| |
| return 0; |
| } |
| |
| static int sis_drm_alloc(struct drm_device *dev, struct drm_file *file, |
| void *data, int pool) |
| { |
| drm_sis_private_t *dev_priv = dev->dev_private; |
| drm_sis_mem_t *mem = data; |
| int retval = 0, user_key; |
| struct drm_memblock_item *item; |
| struct sis_file_private *file_priv = file->driver_priv; |
| |
| mutex_lock(&dev->struct_mutex); |
| |
| if (0 == ((pool == 0) ? dev_priv->vram_initialized : |
| dev_priv->agp_initialized)) { |
| DRM_ERROR |
| ("Attempt to allocate from uninitialized memory manager.\n"); |
| mutex_unlock(&dev->struct_mutex); |
| return -EINVAL; |
| } |
| |
| mem->size = (mem->size + SIS_MM_ALIGN_MASK) >> SIS_MM_ALIGN_SHIFT; |
| item = drm_sman_alloc(&dev_priv->sman, pool, mem->size, 0, 0); |
| if (!item) { |
| retval = -ENOMEM; |
| goto fail_alloc; |
| } |
| |
| again: |
| if (idr_pre_get(&dev_priv->object_idr, GFP_KERNEL) == 0) { |
| retval = -ENOMEM; |
| goto fail_idr; |
| } |
| |
| retval = idr_get_new_above(&dev_priv->object_idr, item, 1, &user_key); |
| if (retval == -EAGAIN) |
| goto again; |
| if (retval) |
| goto fail_idr; |
| |
| list_add(&item->owner_list, &file_priv->obj_list); |
| mutex_unlock(&dev->struct_mutex); |
| |
| mem->offset = ((pool == 0) ? |
| dev_priv->vram_offset : dev_priv->agp_offset) + |
| (item->mm-> |
| offset(item->mm, item->mm_info) << SIS_MM_ALIGN_SHIFT); |
| mem->free = user_key; |
| mem->size = mem->size << SIS_MM_ALIGN_SHIFT; |
| |
| return 0; |
| |
| fail_idr: |
| drm_sman_free(item); |
| fail_alloc: |
| mutex_unlock(&dev->struct_mutex); |
| |
| mem->offset = 0; |
| mem->size = 0; |
| mem->free = 0; |
| |
| DRM_DEBUG("alloc %d, size = %d, offset = %d\n", pool, mem->size, |
| mem->offset); |
| |
| return retval; |
| } |
| |
| static int sis_drm_free(struct drm_device *dev, void *data, struct drm_file *file_priv) |
| { |
| drm_sis_private_t *dev_priv = dev->dev_private; |
| drm_sis_mem_t *mem = data; |
| struct drm_memblock_item *obj; |
| int ret; |
| |
| mutex_lock(&dev->struct_mutex); |
| obj = idr_find(&dev_priv->object_idr, mem->free); |
| if (obj == NULL) { |
| mutex_unlock(&dev->struct_mutex); |
| return -EINVAL; |
| } |
| |
| idr_remove(&dev_priv->object_idr, mem->free); |
| drm_sman_free(obj); |
| mutex_unlock(&dev->struct_mutex); |
| DRM_DEBUG("free = 0x%lx\n", mem->free); |
| |
| return ret; |
| } |
| |
| static int sis_fb_alloc(struct drm_device *dev, void *data, |
| struct drm_file *file_priv) |
| { |
| return sis_drm_alloc(dev, file_priv, data, VIDEO_TYPE); |
| } |
| |
| static int sis_ioctl_agp_init(struct drm_device *dev, void *data, |
| struct drm_file *file_priv) |
| { |
| drm_sis_private_t *dev_priv = dev->dev_private; |
| drm_sis_agp_t *agp = data; |
| int ret; |
| dev_priv = dev->dev_private; |
| |
| mutex_lock(&dev->struct_mutex); |
| ret = drm_sman_set_range(&dev_priv->sman, AGP_TYPE, 0, |
| agp->size >> SIS_MM_ALIGN_SHIFT); |
| |
| if (ret) { |
| DRM_ERROR("AGP memory manager initialisation error\n"); |
| mutex_unlock(&dev->struct_mutex); |
| return ret; |
| } |
| |
| dev_priv->agp_initialized = 1; |
| dev_priv->agp_offset = agp->offset; |
| mutex_unlock(&dev->struct_mutex); |
| |
| DRM_DEBUG("offset = %u, size = %u\n", agp->offset, agp->size); |
| return 0; |
| } |
| |
| static int sis_ioctl_agp_alloc(struct drm_device *dev, void *data, |
| struct drm_file *file_priv) |
| { |
| |
| return sis_drm_alloc(dev, file_priv, data, AGP_TYPE); |
| } |
| |
| static drm_local_map_t *sis_reg_init(struct drm_device *dev) |
| { |
| struct drm_map_list *entry; |
| drm_local_map_t *map; |
| |
| list_for_each_entry(entry, &dev->maplist, head) { |
| map = entry->map; |
| if (!map) |
| continue; |
| if (map->type == _DRM_REGISTERS) |
| return map; |
| } |
| return NULL; |
| } |
| |
| int sis_idle(struct drm_device *dev) |
| { |
| drm_sis_private_t *dev_priv = dev->dev_private; |
| uint32_t idle_reg; |
| unsigned long end; |
| int i; |
| |
| if (dev_priv->idle_fault) |
| return 0; |
| |
| if (dev_priv->mmio == NULL) { |
| dev_priv->mmio = sis_reg_init(dev); |
| if (dev_priv->mmio == NULL) { |
| DRM_ERROR("Could not find register map.\n"); |
| return 0; |
| } |
| } |
| |
| /* |
| * Implement a device switch here if needed |
| */ |
| |
| if (dev_priv->chipset != SIS_CHIP_315) |
| return 0; |
| |
| /* |
| * Timeout after 3 seconds. We cannot use DRM_WAIT_ON here |
| * because its polling frequency is too low. |
| */ |
| |
| end = jiffies + (DRM_HZ * 3); |
| |
| for (i = 0; i < 4; ++i) { |
| do { |
| idle_reg = SIS_READ(0x85cc); |
| } while (!time_after_eq(jiffies, end) && |
| ((idle_reg & 0x80000000) != 0x80000000)); |
| } |
| |
| if (time_after_eq(jiffies, end)) { |
| DRM_ERROR("Graphics engine idle timeout. " |
| "Disabling idle check\n"); |
| dev_priv->idle_fault = 1; |
| } |
| |
| /* |
| * The caller never sees an error code. It gets trapped |
| * in libdrm. |
| */ |
| |
| return 0; |
| } |
| |
| |
| void sis_lastclose(struct drm_device *dev) |
| { |
| drm_sis_private_t *dev_priv = dev->dev_private; |
| |
| if (!dev_priv) |
| return; |
| |
| mutex_lock(&dev->struct_mutex); |
| drm_sman_cleanup(&dev_priv->sman); |
| dev_priv->vram_initialized = 0; |
| dev_priv->agp_initialized = 0; |
| dev_priv->mmio = NULL; |
| mutex_unlock(&dev->struct_mutex); |
| } |
| |
| void sis_reclaim_buffers_locked(struct drm_device *dev, |
| struct drm_file *file) |
| { |
| struct sis_file_private *file_priv = file->driver_priv; |
| struct drm_memblock_item *entry, *next; |
| |
| mutex_lock(&dev->struct_mutex); |
| if (list_empty(&file_priv->obj_list)) { |
| mutex_unlock(&dev->struct_mutex); |
| return; |
| } |
| |
| if (dev->driver->dma_quiescent) |
| dev->driver->dma_quiescent(dev); |
| |
| |
| list_for_each_entry_safe(entry, next, &file_priv->obj_list, |
| owner_list) { |
| drm_sman_free(entry); |
| } |
| mutex_unlock(&dev->struct_mutex); |
| return; |
| } |
| |
| struct drm_ioctl_desc sis_ioctls[] = { |
| DRM_IOCTL_DEF_DRV(SIS_FB_ALLOC, sis_fb_alloc, DRM_AUTH), |
| DRM_IOCTL_DEF_DRV(SIS_FB_FREE, sis_drm_free, DRM_AUTH), |
| DRM_IOCTL_DEF_DRV(SIS_AGP_INIT, sis_ioctl_agp_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY), |
| DRM_IOCTL_DEF_DRV(SIS_AGP_ALLOC, sis_ioctl_agp_alloc, DRM_AUTH), |
| DRM_IOCTL_DEF_DRV(SIS_AGP_FREE, sis_drm_free, DRM_AUTH), |
| DRM_IOCTL_DEF_DRV(SIS_FB_INIT, sis_fb_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY), |
| }; |
| |
| int sis_max_ioctl = DRM_ARRAY_SIZE(sis_ioctls); |