drm: add drm simple memory manager support for SiS and VIA drivers (ce65a44d) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/char/drm/Makefile

+2 −2

Original line number	Diff line number	Diff line
		@@ -16,9 +16,9 @@ i830-objs := i830_drv.o i830_dma.o i830_irq.o
		i915-objs := i915_drv.o i915_dma.o i915_irq.o i915_mem.o
		radeon-objs := radeon_drv.o radeon_cp.o radeon_state.o radeon_mem.o radeon_irq.o r300_cmdbuf.o
		ffb-objs := ffb_drv.o ffb_context.o
		sis-objs := sis_drv.o sis_ds.o sis_mm.o
		sis-objs := sis_drv.o sis_mm.o
		savage-objs := savage_drv.o savage_bci.o savage_state.o
		via-objs := via_irq.o via_drv.o via_ds.o via_map.o via_mm.o via_dma.o via_verifier.o via_video.o via_dmablit.o
		via-objs := via_irq.o via_drv.o via_map.o via_mm.o via_dma.o via_verifier.o via_video.o via_dmablit.o

		ifeq ($(CONFIG_COMPAT),y)
		drm-objs += drm_ioc32.o

drivers/char/drm/sis_drv.c

+35 −3

Original line number	Diff line number	Diff line
		@@ -35,11 +35,43 @@ static struct pci_device_id pciidlist[] = {
		sisdrv_PCI_IDS
		};

		static int sis_driver_load(drm_device_t *dev, unsigned long chipset)
		{
		drm_sis_private_t *dev_priv;
		int ret;

		dev_priv = drm_calloc(1, sizeof(drm_sis_private_t), DRM_MEM_DRIVER);
		if (dev_priv == NULL)
		return DRM_ERR(ENOMEM);

		dev->dev_private = (void *)dev_priv;
		dev_priv->chipset = chipset;
		ret = drm_sman_init(&dev_priv->sman, 2, 12, 8);
		if (ret) {
		drm_free(dev_priv, sizeof(dev_priv), DRM_MEM_DRIVER);
		}

		return ret;
		}

		static int sis_driver_unload(drm_device_t *dev)
		{
		drm_sis_private_t *dev_priv = dev->dev_private;

		drm_sman_takedown(&dev_priv->sman);
		drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);

		return 0;
		}

		static struct drm_driver driver = {
		.driver_features = DRIVER_USE_AGP \| DRIVER_USE_MTRR,
		.context_ctor = sis_init_context,
		.context_dtor = sis_final_context,
		.reclaim_buffers = drm_core_reclaim_buffers,
		.load = sis_driver_load,
		.unload = sis_driver_unload,
		.context_dtor = NULL,
		.reclaim_buffers = NULL,
		.reclaim_buffers_locked = sis_reclaim_buffers_locked,
		.lastclose = sis_lastclose,
		.get_map_ofs = drm_core_get_map_ofs,
		.get_reg_ofs = drm_core_get_reg_ofs,
		.ioctls = sis_ioctls,

drivers/char/drm/sis_drv.h

+15 −9

Original line number	Diff line number	Diff line
		@@ -31,23 +31,29 @@
		/* General customization:
		*/

		#define DRIVER_AUTHOR "SIS"
		#define DRIVER_AUTHOR "SIS, Tungsten Graphics"
		#define DRIVER_NAME "sis"
		#define DRIVER_DESC "SIS 300/630/540"
		#define DRIVER_DATE "20030826"
		#define DRIVER_DATE "20060529"
		#define DRIVER_MAJOR 1
		#define DRIVER_MINOR 1
		#define DRIVER_PATCHLEVEL 0
		#define DRIVER_MINOR 2
		#define DRIVER_PATCHLEVEL 1

		#include "sis_ds.h"
		#include "drm_sman.h"

		typedef struct drm_sis_private {
		memHeap_t *AGPHeap;
		memHeap_t *FBHeap;
		drm_local_map_t *mmio;
		unsigned int idle_fault;
		drm_sman_t sman;
		unsigned int chipset;
		int vram_initialized;
		int agp_initialized;
		unsigned long vram_offset;
		unsigned long agp_offset;
		} drm_sis_private_t;

		extern int sis_init_context(drm_device_t * dev, int context);
		extern int sis_final_context(drm_device_t * dev, int context);
		extern void sis_reclaim_buffers_locked(drm_device_t dev, struct file filp);
		extern void sis_lastclose(drm_device_t *dev);

		extern drm_ioctl_desc_t sis_ioctls[];
		extern int sis_max_ioctl;

drivers/char/drm/sis_ds.c

deleted100644 → 0

+0 −299

Original line number	Diff line number	Diff line
		/* sis_ds.c -- Private header for Direct Rendering Manager -- linux-c --
		* Created: Mon Jan 4 10:05:05 1999 by sclin@sis.com.tw
		*
		* Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
		* 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.
		*
		* Authors:
		* Sung-Ching Lin <sclin@sis.com.tw>
		*
		*/

		#include "drmP.h"
		#include "drm.h"
		#include "sis_ds.h"

		/* Set Data Structure, not check repeated value
		* temporarily used
		*/

		set_t *setInit(void)
		{
		int i;
		set_t *set;

		set = (set_t *) drm_alloc(sizeof(set_t), DRM_MEM_DRIVER);
		if (set != NULL) {
		for (i = 0; i < SET_SIZE; i++) {
		set->list[i].free_next = i + 1;
		set->list[i].alloc_next = -1;
		}
		set->list[SET_SIZE - 1].free_next = -1;
		set->free = 0;
		set->alloc = -1;
		set->trace = -1;
		}
		return set;
		}

		int setAdd(set_t * set, ITEM_TYPE item)
		{
		int free = set->free;

		if (free != -1) {
		set->list[free].val = item;
		set->free = set->list[free].free_next;
		} else {
		return 0;
		}

		set->list[free].alloc_next = set->alloc;
		set->alloc = free;
		set->list[free].free_next = -1;

		return 1;
		}

		int setDel(set_t * set, ITEM_TYPE item)
		{
		int alloc = set->alloc;
		int prev = -1;

		while (alloc != -1) {
		if (set->list[alloc].val == item) {
		if (prev != -1)
		set->list[prev].alloc_next =
		set->list[alloc].alloc_next;
		else
		set->alloc = set->list[alloc].alloc_next;
		break;
		}
		prev = alloc;
		alloc = set->list[alloc].alloc_next;
		}

		if (alloc == -1)
		return 0;

		set->list[alloc].free_next = set->free;
		set->free = alloc;
		set->list[alloc].alloc_next = -1;

		return 1;
		}

		/* setFirst -> setAdd -> setNext is wrong */

		int setFirst(set_t * set, ITEM_TYPE * item)
		{
		if (set->alloc == -1)
		return 0;

		*item = set->list[set->alloc].val;
		set->trace = set->list[set->alloc].alloc_next;

		return 1;
		}

		int setNext(set_t * set, ITEM_TYPE * item)
		{
		if (set->trace == -1)
		return 0;

		*item = set->list[set->trace].val;
		set->trace = set->list[set->trace].alloc_next;

		return 1;
		}

		int setDestroy(set_t * set)
		{
		drm_free(set, sizeof(set_t), DRM_MEM_DRIVER);

		return 1;
		}

		/*
		* GLX Hardware Device Driver common code
		* Copyright (C) 1999 Wittawat Yamwong
		*
		* 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 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
		* WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
		*
		*/

		#define ISFREE(bptr) ((bptr)->free)

		memHeap_t *mmInit(int ofs, int size)
		{
		PMemBlock blocks;

		if (size <= 0)
		return NULL;

		blocks = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock), DRM_MEM_DRIVER);
		if (blocks != NULL) {
		blocks->ofs = ofs;
		blocks->size = size;
		blocks->free = 1;
		return (memHeap_t *) blocks;
		} else
		return NULL;
		}

		/* Checks if a pointer 'b' is part of the heap 'heap' */
		int mmBlockInHeap(memHeap_t * heap, PMemBlock b)
		{
		TMemBlock *p;

		if (heap == NULL \|\| b == NULL)
		return 0;

		p = heap;
		while (p != NULL && p != b) {
		p = p->next;
		}
		if (p == b)
		return 1;
		else
		return 0;
		}

		static TMemBlock SliceBlock(TMemBlock p,
		int startofs, int size,
		int reserved, int alignment)
		{
		TMemBlock *newblock;

		/* break left */
		if (startofs > p->ofs) {
		newblock = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
		DRM_MEM_DRIVER);
		newblock->ofs = startofs;
		newblock->size = p->size - (startofs - p->ofs);
		newblock->free = 1;
		newblock->next = p->next;
		p->size -= newblock->size;
		p->next = newblock;
		p = newblock;
		}

		/* break right */
		if (size < p->size) {
		newblock = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
		DRM_MEM_DRIVER);
		newblock->ofs = startofs + size;
		newblock->size = p->size - size;
		newblock->free = 1;
		newblock->next = p->next;
		p->size = size;
		p->next = newblock;
		}

		/* p = middle block */
		p->align = alignment;
		p->free = 0;
		p->reserved = reserved;
		return p;
		}

		PMemBlock mmAllocMem(memHeap_t * heap, int size, int align2, int startSearch)
		{
		int mask, startofs, endofs;
		TMemBlock *p;

		if (heap == NULL \|\| align2 < 0 \|\| size <= 0)
		return NULL;

		mask = (1 << align2) - 1;
		startofs = 0;
		p = (TMemBlock *) heap;
		while (p != NULL) {
		if (ISFREE(p)) {
		startofs = (p->ofs + mask) & ~mask;
		if (startofs < startSearch) {
		startofs = startSearch;
		}
		endofs = startofs + size;
		if (endofs <= (p->ofs + p->size))
		break;
		}
		p = p->next;
		}
		if (p == NULL)
		return NULL;
		p = SliceBlock(p, startofs, size, 0, mask + 1);
		p->heap = heap;
		return p;
		}

		static __inline__ int Join2Blocks(TMemBlock * p)
		{
		if (p->free && p->next && p->next->free) {
		TMemBlock *q = p->next;
		p->size += q->size;
		p->next = q->next;
		drm_free(q, sizeof(TMemBlock), DRM_MEM_DRIVER);
		return 1;
		}
		return 0;
		}

		int mmFreeMem(PMemBlock b)
		{
		TMemBlock p, prev;

		if (b == NULL)
		return 0;
		if (b->heap == NULL)
		return -1;

		p = b->heap;
		prev = NULL;
		while (p != NULL && p != b) {
		prev = p;
		p = p->next;
		}
		if (p == NULL \|\| p->free \|\| p->reserved)
		return -1;

		p->free = 1;
		Join2Blocks(p);
		if (prev)
		Join2Blocks(prev);
		return 0;
		}

drivers/char/drm/sis_ds.h

deleted100644 → 0

+0 −146

Original line number	Diff line number	Diff line
		/* sis_ds.h -- Private header for Direct Rendering Manager -- linux-c --
		* Created: Mon Jan 4 10:05:05 1999 by sclin@sis.com.tw
		*/
		/*
		* Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
		* 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.
		*
		* Authors:
		* Sung-Ching Lin <sclin@sis.com.tw>
		*
		*/

		#ifndef __SIS_DS_H__
		#define __SIS_DS_H__

		/* Set Data Structure */

		#define SET_SIZE 5000

		typedef unsigned long ITEM_TYPE;

		typedef struct {
		ITEM_TYPE val;
		int alloc_next, free_next;
		} list_item_t;

		typedef struct {
		int alloc;
		int free;
		int trace;
		list_item_t list[SET_SIZE];
		} set_t;

		set_t *setInit(void);
		int setAdd(set_t * set, ITEM_TYPE item);
		int setDel(set_t * set, ITEM_TYPE item);
		int setFirst(set_t * set, ITEM_TYPE * item);
		int setNext(set_t * set, ITEM_TYPE * item);
		int setDestroy(set_t * set);

		/*
		* GLX Hardware Device Driver common code
		* Copyright (C) 1999 Wittawat Yamwong
		*
		* 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 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
		* WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS 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.
		*
		*/

		struct mem_block_t {
		struct mem_block_t *next;
		struct mem_block_t *heap;
		int ofs, size;
		int align;
		unsigned int free:1;
		unsigned int reserved:1;
		};
		typedef struct mem_block_t TMemBlock;
		typedef struct mem_block_t *PMemBlock;

		/* a heap is just the first block in a chain */
		typedef struct mem_block_t memHeap_t;

		static __inline__ int mmBlockSize(PMemBlock b)
		{
		return b->size;
		}

		static __inline__ int mmOffset(PMemBlock b)
		{
		return b->ofs;
		}

		static __inline__ void mmMarkReserved(PMemBlock b)
		{
		b->reserved = 1;
		}

		/*
		* input: total size in bytes
		* return: a heap pointer if OK, NULL if error
		*/
		memHeap_t *mmInit(int ofs, int size);

		/*
		* Allocate 'size' bytes with 2^align2 bytes alignment,
		* restrict the search to free memory after 'startSearch'
		* depth and back buffers should be in different 4mb banks
		* to get better page hits if possible
		* input: size = size of block
		* align2 = 2^align2 bytes alignment
		* startSearch = linear offset from start of heap to begin search
		* return: pointer to the allocated block, 0 if error
		*/
		PMemBlock mmAllocMem(memHeap_t * heap, int size, int align2, int startSearch);

		/*
		* Returns 1 if the block 'b' is part of the heap 'heap'
		*/
		int mmBlockInHeap(PMemBlock heap, PMemBlock b);

		/*
		* Free block starts at offset
		* input: pointer to a block
		* return: 0 if OK, -1 if error
		*/
		int mmFreeMem(PMemBlock b);

		/* For debuging purpose. */
		void mmDumpMemInfo(memHeap_t * mmInit);

		#endif /* __SIS_DS_H__ */