Major whitespace cleanups and fix a potential oops.
The driver can now run with or without FB support.
config DRM_SIS
tristate "SiS video cards"
- depends on DRM && AGP && FB_SIS
+ depends on DRM && AGP
help
Choose this option if you have a SiS 630 or compatibel video
chipset. If M is selected the module will be called sis. AGP
- and SiS FB support is required for this driver to work.
+ support is required for this driver to work.
* Name it sisdrv_##x as there's a conflict with sis_free/malloc in the kernel
* that's used for fb devices
*/
+#ifdef __linux__
#define DRM(x) sisdrv_##x
+#else
+#define DRM(x) sis_##x
+#endif
/* General customization:
*/
#define __HAVE_MTRR 1
#define __HAVE_CTX_BITMAP 1
-#define DRIVER_AUTHOR "SIS"
-#define DRIVER_NAME "sis"
-#define DRIVER_DESC "SIS 300/630/540"
-#define DRIVER_DATE "20010503"
-#define DRIVER_MAJOR 1
-#define DRIVER_MINOR 0
-#define DRIVER_PATCHLEVEL 0
+#define DRIVER_AUTHOR "SIS"
+#define DRIVER_NAME "sis"
+#define DRIVER_DESC "SIS 300/630/540"
+#define DRIVER_DATE "20030826"
+#define DRIVER_MAJOR 1
+#define DRIVER_MINOR 1
+#define DRIVER_PATCHLEVEL 0
#define DRIVER_IOCTLS \
- [DRM_IOCTL_NR(SIS_IOCTL_FB_ALLOC)] = { sis_fb_alloc, 1, 0 }, \
- [DRM_IOCTL_NR(SIS_IOCTL_FB_FREE)] = { sis_fb_free, 1, 0 }, \
- /* AGP Memory Management */ \
- [DRM_IOCTL_NR(SIS_IOCTL_AGP_INIT)] = { sisp_agp_init, 1, 0 }, \
- [DRM_IOCTL_NR(SIS_IOCTL_AGP_ALLOC)] = { sisp_agp_alloc, 1, 0 }, \
- [DRM_IOCTL_NR(SIS_IOCTL_AGP_FREE)] = { sisp_agp_free, 1, 0 }
-#if 0 /* these don't appear to be defined */
- /* SIS Stereo */
- [DRM_IOCTL_NR(DRM_IOCTL_CONTROL)] = { sis_control, 1, 1 },
- [DRM_IOCTL_NR(SIS_IOCTL_FLIP)] = { sis_flip, 1, 1 },
- [DRM_IOCTL_NR(SIS_IOCTL_FLIP_INIT)] = { sis_flip_init, 1, 1 },
- [DRM_IOCTL_NR(SIS_IOCTL_FLIP_FINAL)] = { sis_flip_final, 1, 1 }
-#endif
+ [DRM_IOCTL_NR(DRM_IOCTL_SIS_FB_ALLOC)] = { sis_fb_alloc, 1, 0 }, \
+ [DRM_IOCTL_NR(DRM_IOCTL_SIS_FB_FREE)] = { sis_fb_free, 1, 0 }, \
+ [DRM_IOCTL_NR(DRM_IOCTL_SIS_AGP_INIT)] = { sis_ioctl_agp_init, 1, 1 }, \
+ [DRM_IOCTL_NR(DRM_IOCTL_SIS_AGP_ALLOC)] = { sis_ioctl_agp_alloc, 1, 0 }, \
+ [DRM_IOCTL_NR(DRM_IOCTL_SIS_AGP_FREE)] = { sis_ioctl_agp_free, 1, 0 }, \
+ [DRM_IOCTL_NR(DRM_IOCTL_SIS_FB_INIT)] = { sis_fb_init, 1, 1 }
#define __HAVE_COUNTERS 5
-#ifndef _sis_drm_public_h_
-#define _sis_drm_public_h_
+#ifndef __SIS_DRM_H__
+#define __SIS_DRM_H__
/* SiS specific ioctls */
-#define SIS_IOCTL_FB_ALLOC DRM_IOWR(0x44, drm_sis_mem_t)
-#define SIS_IOCTL_FB_FREE DRM_IOW( 0x45, drm_sis_mem_t)
-#define SIS_IOCTL_AGP_INIT DRM_IOWR(0x53, drm_sis_agp_t)
-#define SIS_IOCTL_AGP_ALLOC DRM_IOWR(0x54, drm_sis_mem_t)
-#define SIS_IOCTL_AGP_FREE DRM_IOW( 0x55, drm_sis_mem_t)
-#define SIS_IOCTL_FLIP DRM_IOW( 0x48, drm_sis_flip_t)
-#define SIS_IOCTL_FLIP_INIT DRM_IO( 0x49)
-#define SIS_IOCTL_FLIP_FINAL DRM_IO( 0x50)
+#define DRM_IOCTL_SIS_FB_ALLOC DRM_IOWR(0x44, drm_sis_mem_t)
+#define DRM_IOCTL_SIS_FB_FREE DRM_IOW( 0x45, drm_sis_mem_t)
+#define DRM_IOCTL_SIS_AGP_INIT DRM_IOWR(0x53, drm_sis_agp_t)
+#define DRM_IOCTL_SIS_AGP_ALLOC DRM_IOWR(0x54, drm_sis_mem_t)
+#define DRM_IOCTL_SIS_AGP_FREE DRM_IOW( 0x55, drm_sis_mem_t)
+#define DRM_IOCTL_SIS_FB_INIT DRM_IOW( 0x56, drm_sis_fb_t)
+/*
+#define DRM_IOCTL_SIS_FLIP DRM_IOW( 0x48, drm_sis_flip_t)
+#define DRM_IOCTL_SIS_FLIP_INIT DRM_IO( 0x49)
+#define DRM_IOCTL_SIS_FLIP_FINAL DRM_IO( 0x50)
+*/
typedef struct {
- int context;
- unsigned int offset;
- unsigned int size;
- unsigned int free;
+ int context;
+ unsigned int offset;
+ unsigned int size;
+ unsigned long free;
} drm_sis_mem_t;
typedef struct {
- unsigned int offset, size;
+ unsigned int offset, size;
} drm_sis_agp_t;
typedef struct {
- unsigned int left, right;
-} drm_sis_flip_t;
+ unsigned int offset, size;
+} drm_sis_fb_t;
-#ifdef __KERNEL__
-
-int sis_fb_alloc(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg);
-int sis_fb_free(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg);
-
-int sisp_agp_init(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg);
-int sisp_agp_alloc(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg);
-int sisp_agp_free(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg);
-
-#endif
-
-#endif
+#endif /* __SIS_DRM_H__ */
#ifndef _SIS_DRV_H_
#define _SIS_DRV_H_
+#include "sis_ds.h"
+
typedef struct drm_sis_private {
drm_map_t *buffers;
-} drm_sis_private_t;
-/* Stereo ? - this was never committed */
+ memHeap_t *AGPHeap;
+ memHeap_t *FBHeap;
+} drm_sis_private_t;
-int sis_flip(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg);
-int sis_flip_init(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg);
-int sis_flip_final(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg);
-void flip_final(void);
+extern int sis_fb_alloc( DRM_IOCTL_ARGS );
+extern int sis_fb_free( DRM_IOCTL_ARGS );
+extern int sis_ioctl_agp_init( DRM_IOCTL_ARGS );
+extern int sis_ioctl_agp_alloc( DRM_IOCTL_ARGS );
+extern int sis_ioctl_agp_free( DRM_IOCTL_ARGS );
+extern int sis_fb_init( DRM_IOCTL_ARGS );
#endif
*
*/
-#include <linux/module.h>
-#include <linux/delay.h>
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/poll.h>
-#include <asm/io.h>
-#include <linux/pci.h>
-
+#include "sis.h"
+#include "drmP.h"
+#include "drm.h"
#include "sis_ds.h"
/* Set Data Structure, not check repeated value
set_t *setInit(void)
{
- int i;
- set_t *set;
-
- set = (set_t *)MALLOC(sizeof(set_t));
- if (set) {
- 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 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;
+ 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;
+ 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;
+ 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;
+ if (set->alloc == -1)
+ return 0;
- *item = set->list[set->alloc].val;
- set->trace = set->list[set->alloc].alloc_next;
+ *item = set->list[set->alloc].val;
+ set->trace = set->list[set->alloc].alloc_next;
- return 1;
+ 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;
+ if (set->trace == -1)
+ return 0;
+
+ *item = set->list[set->trace].val;
+ set->trace = set->list[set->trace].alloc_next;
- return 1;
+ return 1;
}
int setDestroy(set_t *set)
{
- FREE(set);
+ DRM(free)(set, sizeof(set_t), DRM_MEM_DRIVER);
- return 1;
+ return 1;
}
/*
#define ISFREE(bptr) ((bptr)->free)
-#define PRINTF(fmt, arg...) do{}while(0)
-#define fprintf(fmt, arg...) do{}while(0)
-
-static void *calloc(size_t nmemb, size_t size)
-{
- void *addr;
- addr = kmalloc(nmemb*size, GFP_KERNEL);
- if (addr)
- memset(addr, 0, nmemb*size);
- return addr;
-}
-#define free(n) kfree(n)
-
-void mmDumpMemInfo( memHeap_t *heap )
+memHeap_t *mmInit(int ofs,
+ int size)
{
- TMemBlock *p;
-
- PRINTF ("Memory heap %p:\n", heap);
- if (heap == 0) {
- PRINTF (" heap == 0\n");
- } else {
- p = (TMemBlock *)heap;
- while (p) {
- PRINTF (" Offset:%08x, Size:%08x, %c%c\n",p->ofs,p->size,
- p->free ? '.':'U',
- p->reserved ? 'R':'.');
- p = p->next;
- }
- }
- PRINTF ("End of memory blocks\n");
+ PMemBlock blocks;
+
+ if (size <= 0)
+ return 0;
+
+ 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 0;
}
-memHeap_t *mmInit(int ofs,
- int size)
+/* Checks if a pointer 'b' is part of the heap 'heap' */
+int mmBlockInHeap(memHeap_t *heap, PMemBlock b)
{
- PMemBlock blocks;
-
- if (size <= 0) {
- return 0;
- }
- blocks = (TMemBlock *) calloc(1,sizeof(TMemBlock));
- if (blocks) {
- blocks->ofs = ofs;
- blocks->size = size;
- blocks->free = 1;
- return (memHeap_t *)blocks;
- } else
- return 0;
+ 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;
}
/* Kludgey workaround for existing i810 server. Remove soon.
int ofs,
int size )
{
- PMemBlock blocks;
- blocks = (TMemBlock *) calloc(2,sizeof(TMemBlock));
- if (blocks) {
- blocks[0].size = size;
- blocks[0].free = 1;
- blocks[0].ofs = ofs;
- blocks[0].next = &blocks[1];
-
- /* Discontinuity - stops JoinBlock from trying to join non-adjacent
- * ranges.
- */
- blocks[1].size = 0;
- blocks[1].free = 0;
- blocks[1].ofs = ofs+size;
- blocks[1].next = (PMemBlock) heap;
- return (memHeap_t *)blocks;
- }
- else
- return heap;
+ PMemBlock blocks;
+ blocks = (TMemBlock *)DRM(calloc)(2, sizeof(TMemBlock), DRM_MEM_DRIVER);
+ if (blocks != NULL) {
+ blocks[0].size = size;
+ blocks[0].free = 1;
+ blocks[0].ofs = ofs;
+ blocks[0].next = &blocks[1];
+
+ /* Discontinuity - stops JoinBlock from trying to join
+ * non-adjacent ranges.
+ */
+ blocks[1].size = 0;
+ blocks[1].free = 0;
+ blocks[1].ofs = ofs+size;
+ blocks[1].next = (PMemBlock)heap;
+ return (memHeap_t *)blocks;
+ } else
+ return heap;
}
static TMemBlock* SliceBlock(TMemBlock *p,
int startofs, int size,
int reserved, int alignment)
{
- TMemBlock *newblock;
-
- /* break left */
- if (startofs > p->ofs) {
- newblock = (TMemBlock*) calloc(1,sizeof(TMemBlock));
- 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*) calloc(1,sizeof(TMemBlock));
- 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;
+ 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 || align2 < 0 || size <= 0)
- return NULL;
- mask = (1 << align2)-1;
- startofs = 0;
- p = (TMemBlock *)heap;
- while (p) {
- 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)
- return NULL;
- p = SliceBlock(p,startofs,size,0,mask+1);
- p->heap = heap;
- return p;
+ 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;
- free(q);
- return 1;
- }
- return 0;
+ 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)
- return 0;
- if (!b->heap) {
- fprintf(stderr, "no heap\n");
- return -1;
- }
- p = b->heap;
- prev = NULL;
- while (p && p != b) {
- prev = p;
- p = p->next;
- }
- if (!p || p->free || p->reserved) {
- if (!p)
- fprintf(stderr, "block not found in heap\n");
- else if (p->free)
- fprintf(stderr, "block already free\n");
- else
- fprintf(stderr, "block is reserved\n");
- return -1;
- }
- p->free = 1;
- Join2Blocks(p);
- if (prev)
- Join2Blocks(prev);
- return 0;
+ 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;
}
int mmReserveMem(memHeap_t *heap, int offset,int size)
{
- int endofs;
- TMemBlock *p;
-
- if (!heap || size <= 0)
- return -1;
- endofs = offset+size;
- p = (TMemBlock *)heap;
- while (p && p->ofs <= offset) {
- if (ISFREE(p) && endofs <= (p->ofs+p->size)) {
- SliceBlock(p,offset,size,1,1);
- return 0;
- }
- p = p->next;
- }
- return -1;
+ int endofs;
+ TMemBlock *p;
+
+ if (heap == NULL || size <= 0)
+ return -1;
+
+ endofs = offset + size;
+ p = (TMemBlock *)heap;
+ while (p && p->ofs <= offset) {
+ if (ISFREE(p) && endofs <= (p->ofs+p->size)) {
+ SliceBlock(p,offset,size,1,1);
+ return 0;
+ }
+ p = p->next;
+ }
+ return -1;
}
int mmFreeReserved(memHeap_t *heap, int offset)
{
- TMemBlock *p,*prev;
-
- if (!heap)
- return -1;
- p = (TMemBlock *)heap;
- prev = NULL;
- while (p && p->ofs != offset) {
- prev = p;
- p = p->next;
- }
- if (!p || !p->reserved)
- return -1;
- p->free = 1;
- p->reserved = 0;
- Join2Blocks(p);
- if (prev)
- Join2Blocks(prev);
- return 0;
+ TMemBlock *p,*prev;
+
+ if (heap == NULL)
+ return -1;
+
+ p = (TMemBlock *)heap;
+ prev = NULL;
+ while (p != NULL && p->ofs != offset) {
+ prev = p;
+ p = p->next;
+ }
+ if (p == NULL || !p->reserved)
+ return -1;
+
+ p->free = 1;
+ p->reserved = 0;
+ Join2Blocks(p);
+ if (prev != NULL)
+ Join2Blocks(prev);
+ return 0;
}
void mmDestroy(memHeap_t *heap)
{
- TMemBlock *p,*q;
-
- if (!heap)
- return;
- p = (TMemBlock *)heap;
- while (p) {
- q = p->next;
- free(p);
- p = q;
- }
+ TMemBlock *p,*q;
+
+ if (heap == NULL)
+ return;
+
+ p = (TMemBlock *)heap;
+ while (p != NULL) {
+ q = p->next;
+ DRM(free)(p, sizeof(TMemBlock), DRM_MEM_DRIVER);
+ p = q;
+ }
}
*
*/
-#ifndef _sis_ds_h_
-#define _sis_ds_h_
+#ifndef __SIS_DS_H__
+#define __SIS_DS_H__
/* Set Data Structure */
#define SET_SIZE 5000
-#define MALLOC(s) kmalloc(s, GFP_KERNEL)
-#define FREE(s) kfree(s)
typedef unsigned int ITEM_TYPE;
typedef struct {
- ITEM_TYPE val;
- int alloc_next, free_next;
+ 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];
+ int alloc;
+ int free;
+ int trace;
+ list_item_t list[SET_SIZE];
} set_t;
set_t *setInit(void);
int setNext(set_t *set, ITEM_TYPE *item);
int setDestroy(set_t *set);
-#endif
-
/*
* GLX Hardware Device Driver common code
* Copyright (C) 1999 Keith Whitwell
*
*/
-#ifndef MM_INC
-#define MM_INC
-
struct mem_block_t {
- struct mem_block_t *next;
- struct mem_block_t *heap;
- int ofs,size;
- int align;
- int free:1;
- int reserved:1;
+ struct mem_block_t *next;
+ struct mem_block_t *heap;
+ int ofs,size;
+ int align;
+ int free:1;
+ int reserved:1;
};
typedef struct mem_block_t TMemBlock;
typedef struct mem_block_t *PMemBlock;
typedef struct mem_block_t memHeap_t;
static __inline__ int mmBlockSize(PMemBlock b)
-{ return b->size; }
+{
+ return b->size;
+}
static __inline__ int mmOffset(PMemBlock b)
-{ return b->ofs; }
+{
+ return b->ofs;
+}
static __inline__ void mmMarkReserved(PMemBlock b)
-{ b->reserved = 1; }
+{
+ b->reserved = 1;
+}
/*
* input: total size in bytes
*/
memHeap_t *mmInit( int ofs, int size );
-
-
memHeap_t *mmAddRange( memHeap_t *heap,
int ofs,
int size );
-
/*
* Allocate 'size' bytes with 2^align2 bytes alignment,
* restrict the search to free memory after 'startSearch'
* 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 );
+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 );
+int mmFreeMem( PMemBlock b );
/*
* Reserve 'size' bytes block start at offset
/* For debuging purpose. */
void mmDumpMemInfo( memHeap_t *mmInit );
-#endif
+#endif /* __SIS_DS_H__ */
*
*/
-#include <linux/config.h>
#include "sis.h"
-#include "video/sisfb.h"
#include "drmP.h"
#include "sis_drm.h"
#include "sis_drv.h"
#include "sis_ds.h"
+#if defined(__linux__) && defined(CONFIG_FB_SIS)
+#include <linux/sisfb.h>
+#endif
#define MAX_CONTEXT 100
#define VIDEO_TYPE 0
#define AGP_TYPE 1
typedef struct {
- int used;
- int context;
- set_t *sets[2]; /* 0 for video, 1 for AGP */
+ int used;
+ int context;
+ set_t *sets[2]; /* 0 for video, 1 for AGP */
} sis_context_t;
static sis_context_t global_ppriv[MAX_CONTEXT];
+
static int add_alloc_set(int context, int type, unsigned int val)
{
- int i, retval = 0;
-
- for(i = 0; i < MAX_CONTEXT; i++)
- if(global_ppriv[i].used && global_ppriv[i].context == context){
- retval = setAdd(global_ppriv[i].sets[type], val);
- break;
- }
- return retval;
+ int i, retval = 0;
+
+ for (i = 0; i < MAX_CONTEXT; i++) {
+ if (global_ppriv[i].used && global_ppriv[i].context == context)
+ {
+ retval = setAdd(global_ppriv[i].sets[type], val);
+ break;
+ }
+ }
+ return retval;
}
static int del_alloc_set(int context, int type, unsigned int val)
{
- int i, retval = 0;
- for(i = 0; i < MAX_CONTEXT; i++)
- if(global_ppriv[i].used && global_ppriv[i].context == context){
- retval = setDel(global_ppriv[i].sets[type], val);
- break;
- }
- return retval;
+ int i, retval = 0;
+
+ for (i = 0; i < MAX_CONTEXT; i++) {
+ if (global_ppriv[i].used && global_ppriv[i].context == context)
+ {
+ retval = setDel(global_ppriv[i].sets[type], val);
+ break;
+ }
+ }
+ return retval;
}
/* fb management via fb device */
-#if 1
-int sis_fb_alloc(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg)
+#if defined(__linux__) && defined(CONFIG_FB_SIS)
+
+int sis_fb_init( DRM_IOCTL_ARGS )
{
- drm_sis_mem_t fb;
- struct sis_memreq req;
- int retval = 0;
-
- if (copy_from_user(&fb, (drm_sis_mem_t *)arg, sizeof(fb)))
- return -EFAULT;
-
- req.size = fb.size;
- sis_malloc(&req);
- if(req.offset){
- /* TODO */
- fb.offset = req.offset;
- fb.free = req.offset;
- if(!add_alloc_set(fb.context, VIDEO_TYPE, fb.free)){
- DRM_DEBUG("adding to allocation set fails\n");
- sis_free(req.offset);
- retval = -1;
- }
- }
- else{
- fb.offset = 0;
- fb.size = 0;
- fb.free = 0;
- }
-
- if (copy_to_user((drm_sis_mem_t *)arg, &fb, sizeof(fb))) return -EFAULT;
+ return 0;
+}
+
+int sis_fb_alloc( DRM_IOCTL_ARGS )
+{
+ drm_sis_mem_t fb;
+ struct sis_memreq req;
+ int retval = 0;
+
+ DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t *)data, sizeof(fb));
+
+ req.size = fb.size;
+ sis_malloc(&req);
+ if (req.offset) {
+ /* TODO */
+ fb.offset = req.offset;
+ fb.free = req.offset;
+ if (!add_alloc_set(fb.context, VIDEO_TYPE, fb.free)) {
+ DRM_DEBUG("adding to allocation set fails\n");
+ sis_free(req.offset);
+ retval = DRM_ERR(EINVAL);
+ }
+ } else {
+ fb.offset = 0;
+ fb.size = 0;
+ fb.free = 0;
+ }
- DRM_DEBUG("alloc fb, size = %d, offset = %ld\n", fb.size, req.offset);
+ DRM_COPY_TO_USER_IOCTL((drm_sis_mem_t *)data, fb, sizeof(fb));
- return retval;
+ DRM_DEBUG("alloc fb, size = %d, offset = %ld\n", fb.size, req.offset);
+
+ return retval;
}
-int sis_fb_free(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg)
+int sis_fb_free( DRM_IOCTL_ARGS )
{
- drm_sis_mem_t fb;
- int retval = 0;
-
- if (copy_from_user(&fb, (drm_sis_mem_t *)arg, sizeof(fb)))
- return -EFAULT;
-
- if(!fb.free){
- return -1;
- }
+ drm_sis_mem_t fb;
+ int retval = 0;
- sis_free(fb.free);
- if(!del_alloc_set(fb.context, VIDEO_TYPE, fb.free))
- retval = -1;
+ DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t *)data, sizeof(fb));
- DRM_DEBUG("free fb, offset = %d\n", fb.free);
-
- return retval;
+ if (!fb.free)
+ return DRM_ERR(EINVAL);
+
+ if (!del_alloc_set(fb.context, VIDEO_TYPE, fb.free))
+ retval = DRM_ERR(EINVAL);
+ sis_free(fb.free);
+
+ DRM_DEBUG("free fb, offset = %d\n", fb.free);
+
+ return retval;
}
#else
-int sis_fb_alloc(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg)
+/* Called by the X Server to initialize the FB heap. Allocations will fail
+ * unless this is called. Offset is the beginning of the heap from the
+ * framebuffer offset (MaxXFBMem in XFree86).
+ *
+ * Memory layout according to Thomas Winischofer:
+ * |------------------|DDDDDDDDDDDDDDDDDDDDDDDDDDDDD|HHHH|CCCCCCCCCCC|
+ *
+ * X driver/sisfb HW- Command-
+ * framebuffer memory DRI heap Cursor queue
+ */
+int sis_fb_init( DRM_IOCTL_ARGS )
{
- return -1;
+ DRM_DEVICE;
+ drm_sis_private_t *dev_priv = dev->dev_private;
+ drm_sis_fb_t fb;
+
+ DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_fb_t *)data, sizeof(fb));
+
+ if (dev_priv == NULL) {
+ dev->dev_private = DRM(calloc)(1, sizeof(drm_sis_private_t),
+ DRM_MEM_DRIVER);
+ dev_priv = dev->dev_private;
+ if (dev_priv == NULL)
+ return ENOMEM;
+ }
+
+ if (dev_priv->FBHeap != NULL)
+ return DRM_ERR(EINVAL);
+
+ dev_priv->FBHeap = mmInit(fb.offset, fb.size);
+
+ DRM_DEBUG("offset = %u, size = %u", fb.offset, fb.size);
+
+ return 0;
}
-int sis_fb_free(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg)
+int sis_fb_alloc( DRM_IOCTL_ARGS )
{
- return 0;
+ DRM_DEVICE;
+ drm_sis_private_t *dev_priv = dev->dev_private;
+ drm_sis_mem_t fb;
+ PMemBlock block;
+ int retval = 0;
+
+ if (dev_priv == NULL || dev_priv->FBHeap == NULL)
+ return DRM_ERR(EINVAL);
+
+ DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t *)data, sizeof(fb));
+
+ block = mmAllocMem(dev_priv->FBHeap, fb.size, 0, 0);
+ if (block) {
+ /* TODO */
+ fb.offset = block->ofs;
+ fb.free = (unsigned long)block;
+ if (!add_alloc_set(fb.context, VIDEO_TYPE, fb.free)) {
+ DRM_DEBUG("adding to allocation set fails\n");
+ mmFreeMem((PMemBlock)fb.free);
+ retval = DRM_ERR(EINVAL);
+ }
+ } else {
+ fb.offset = 0;
+ fb.size = 0;
+ fb.free = 0;
+ }
+
+ DRM_COPY_TO_USER_IOCTL((drm_sis_mem_t *)data, fb, sizeof(fb));
+
+ DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size, fb.offset);
+
+ return retval;
+}
+
+int sis_fb_free( DRM_IOCTL_ARGS )
+{
+ DRM_DEVICE;
+ drm_sis_private_t *dev_priv = dev->dev_private;
+ drm_sis_mem_t fb;
+
+ if (dev_priv == NULL || dev_priv->FBHeap == NULL)
+ return DRM_ERR(EINVAL);
+
+ DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t *)data, sizeof(fb));
+
+ if (!mmBlockInHeap(dev_priv->FBHeap, (PMemBlock)fb.free))
+ return DRM_ERR(EINVAL);
+
+ if (!del_alloc_set(fb.context, VIDEO_TYPE, fb.free))
+ return DRM_ERR(EINVAL);
+ mmFreeMem((PMemBlock)fb.free);
+
+ DRM_DEBUG("free fb, free = 0x%lx\n", fb.free);
+
+ return 0;
}
#endif
/* agp memory management */
-#if 1
-
-static memHeap_t *AgpHeap = NULL;
-int sisp_agp_init(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg)
+int sis_ioctl_agp_init( DRM_IOCTL_ARGS )
{
- drm_sis_agp_t agp;
-
- if (copy_from_user(&agp, (drm_sis_agp_t *)arg, sizeof(agp)))
- return -EFAULT;
+ DRM_DEVICE;
+ drm_sis_private_t *dev_priv = dev->dev_private;
+ drm_sis_agp_t agp;
+
+ if (dev_priv == NULL) {
+ dev->dev_private = DRM(calloc)(1, sizeof(drm_sis_private_t),
+ DRM_MEM_DRIVER);
+ dev_priv = dev->dev_private;
+ if (dev_priv == NULL)
+ return ENOMEM;
+ }
+
+ if (dev_priv->AGPHeap != NULL)
+ return DRM_ERR(EINVAL);
+
+ DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_agp_t *)data, sizeof(agp));
- AgpHeap = mmInit(agp.offset, agp.size);
+ dev_priv->AGPHeap = mmInit(agp.offset, agp.size);
- DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);
+ DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);
- return 0;
+ return 0;
}
-int sisp_agp_alloc(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg)
+int sis_ioctl_agp_alloc( DRM_IOCTL_ARGS )
{
- drm_sis_mem_t agp;
- PMemBlock block;
- int retval = 0;
+ DRM_DEVICE;
+ drm_sis_private_t *dev_priv = dev->dev_private;
+ drm_sis_mem_t agp;
+ PMemBlock block;
+ int retval = 0;
- if(!AgpHeap)
- return -1;
+ if (dev_priv == NULL || dev_priv->AGPHeap == NULL)
+ return DRM_ERR(EINVAL);
- if (copy_from_user(&agp, (drm_sis_mem_t *)arg, sizeof(agp)))
- return -EFAULT;
+ DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_mem_t *)data, sizeof(agp));
- block = mmAllocMem(AgpHeap, agp.size, 0, 0);
- if(block){
- /* TODO */
- agp.offset = block->ofs;
- agp.free = (unsigned long)block;
- if(!add_alloc_set(agp.context, AGP_TYPE, agp.free)){
- DRM_DEBUG("adding to allocation set fails\n");
- mmFreeMem((PMemBlock)(unsigned long)agp.free);
- retval = -1;
- }
- }
- else{
- agp.offset = 0;
- agp.size = 0;
- agp.free = 0;
- }
-
- if (copy_to_user((drm_sis_mem_t *)arg, &agp, sizeof(agp))) return -EFAULT;
+ block = mmAllocMem(dev_priv->AGPHeap, agp.size, 0, 0);
+ if (block) {
+ /* TODO */
+ agp.offset = block->ofs;
+ agp.free = (unsigned long)block;
+ if (!add_alloc_set(agp.context, AGP_TYPE, agp.free)) {
+ DRM_DEBUG("adding to allocation set fails\n");
+ mmFreeMem((PMemBlock)agp.free);
+ retval = -1;
+ }
+ } else {
+ agp.offset = 0;
+ agp.size = 0;
+ agp.free = 0;
+ }
- DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size, agp.offset);
+ DRM_COPY_TO_USER_IOCTL((drm_sis_mem_t *)data, agp, sizeof(agp));
- return retval;
+ DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size, agp.offset);
+
+ return retval;
}
-int sisp_agp_free(struct inode *inode, struct file *filp, unsigned int cmd,
- unsigned long arg)
+int sis_ioctl_agp_free( DRM_IOCTL_ARGS )
{
- drm_sis_mem_t agp;
- int retval = 0;
-
- if(!AgpHeap)
- return -1;
-
- if (copy_from_user(&agp, (drm_sis_mem_t *)arg, sizeof(agp)))
- return -EFAULT;
-
- if(!agp.free){
- return -1;
- }
+ DRM_DEVICE;
+ drm_sis_private_t *dev_priv = dev->dev_private;
+ drm_sis_mem_t agp;
- mmFreeMem((PMemBlock)(unsigned long)agp.free);
- if(!del_alloc_set(agp.context, AGP_TYPE, agp.free))
- retval = -1;
+ if (dev_priv == NULL || dev_priv->AGPHeap == NULL)
+ return DRM_ERR(EINVAL);
- DRM_DEBUG("free agp, free = %d\n", agp.free);
-
- return retval;
-}
+ DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_mem_t *)data, sizeof(agp));
-#endif
+ if (!mmBlockInHeap(dev_priv->AGPHeap, (PMemBlock)agp.free))
+ return DRM_ERR(EINVAL);
+
+ mmFreeMem((PMemBlock)agp.free);
+ if (!del_alloc_set(agp.context, AGP_TYPE, agp.free))
+ return DRM_ERR(EINVAL);
+
+ DRM_DEBUG("free agp, free = 0x%lx\n", agp.free);
+
+ return 0;
+}
int sis_init_context(int context)
{
int i;
-
- for(i = 0; i < MAX_CONTEXT ; i++)
- if(global_ppriv[i].used && (global_ppriv[i].context == context))
- break;
-
- if(i >= MAX_CONTEXT){
- for(i = 0; i < MAX_CONTEXT ; i++){
- if(!global_ppriv[i].used){
- global_ppriv[i].context = context;
- global_ppriv[i].used = 1;
- global_ppriv[i].sets[0] = setInit();
- global_ppriv[i].sets[1] = setInit();
- DRM_DEBUG("init allocation set, socket=%d, context = %d\n",
- i, context);
- break;
- }
- }
- if((i >= MAX_CONTEXT) || (global_ppriv[i].sets[0] == NULL) ||
- (global_ppriv[i].sets[1] == NULL)){
- return 0;
- }
+
+ for (i = 0; i < MAX_CONTEXT ; i++) {
+ if (global_ppriv[i].used &&
+ (global_ppriv[i].context == context))
+ break;
+ }
+
+ if (i >= MAX_CONTEXT) {
+ for (i = 0; i < MAX_CONTEXT ; i++) {
+ if (!global_ppriv[i].used) {
+ global_ppriv[i].context = context;
+ global_ppriv[i].used = 1;
+ global_ppriv[i].sets[0] = setInit();
+ global_ppriv[i].sets[1] = setInit();
+ DRM_DEBUG("init allocation set, socket=%d, "
+ "context = %d\n", i, context);
+ break;
+ }
+ }
+ if ((i >= MAX_CONTEXT) || (global_ppriv[i].sets[0] == NULL) ||
+ (global_ppriv[i].sets[1] == NULL))
+ {
+ return 0;
+ }
}
return 1;
{
int i;
- for(i=0; i<MAX_CONTEXT; i++)
- if(global_ppriv[i].used && (global_ppriv[i].context == context))
- break;
-
- if(i < MAX_CONTEXT){
- set_t *set;
- unsigned int item;
- int retval;
-
- DRM_DEBUG("find socket %d, context = %d\n", i, context);
-
- /* Video Memory */
- set = global_ppriv[i].sets[0];
- retval = setFirst(set, &item);
- while(retval){
- DRM_DEBUG("free video memory 0x%x\n", item);
- sis_free(item);
- retval = setNext(set, &item);
- }
- setDestroy(set);
-
- /* AGP Memory */
- set = global_ppriv[i].sets[1];
- retval = setFirst(set, &item);
- while(retval){
- DRM_DEBUG("free agp memory 0x%x\n", item);
- mmFreeMem((PMemBlock)(unsigned long)item);
- retval = setNext(set, &item);
- }
- setDestroy(set);
-
- global_ppriv[i].used = 0;
- }
+ for (i=0; i<MAX_CONTEXT; i++) {
+ if (global_ppriv[i].used &&
+ (global_ppriv[i].context == context))
+ break;
+ }
- /* turn-off auto-flip */
- /* TODO */
-#if defined(SIS_STEREO)
- flip_final();
+ if (i < MAX_CONTEXT) {
+ set_t *set;
+ unsigned int item;
+ int retval;
+
+ DRM_DEBUG("find socket %d, context = %d\n", i, context);
+
+ /* Video Memory */
+ set = global_ppriv[i].sets[0];
+ retval = setFirst(set, &item);
+ while (retval) {
+ DRM_DEBUG("free video memory 0x%x\n", item);
+#if defined(__linux__) && defined(CONFIG_FB_SIS)
+ sis_free(item);
+#else
+ mmFreeMem((PMemBlock)item);
#endif
+ retval = setNext(set, &item);
+ }
+ setDestroy(set);
+
+ /* AGP Memory */
+ set = global_ppriv[i].sets[1];
+ retval = setFirst(set, &item);
+ while (retval) {
+ DRM_DEBUG("free agp memory 0x%x\n", item);
+ mmFreeMem((PMemBlock)item);
+ retval = setNext(set, &item);
+ }
+ setDestroy(set);
+
+ global_ppriv[i].used = 0;
+ }
return 1;
}
projects / linux / commitdiff