sis_mm.c 9.41 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
/* sis_mm.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 "sis_drm.h"
#include "sis_drv.h"
#include "sis_ds.h"
35
#if defined(__linux__) && defined(CONFIG_FB_SIS)
36
#include <video/sisfb.h>
37
#endif
38 39 40 41 42 43

#define MAX_CONTEXT 100
#define VIDEO_TYPE 0 
#define AGP_TYPE 1

typedef struct {
44 45 46
	int used;
	int context;
	set_t *sets[2]; /* 0 for video, 1 for AGP */
47 48 49 50
} sis_context_t;

static sis_context_t global_ppriv[MAX_CONTEXT];

51

52 53
static int add_alloc_set(int context, int type, unsigned int val)
{
54 55 56 57 58 59 60 61 62 63
	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;
64 65 66 67
}

static int del_alloc_set(int context, int type, unsigned int val)
{  
68 69 70 71 72 73 74 75 76 77
	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;
78 79 80
}

/* fb management via fb device */ 
81 82 83
#if defined(__linux__) && defined(CONFIG_FB_SIS)

int sis_fb_init( DRM_IOCTL_ARGS )
84
{
85 86 87 88 89 90 91
	return 0;
}

int sis_fb_alloc( DRM_IOCTL_ARGS )
{
	drm_sis_mem_t fb;
	struct sis_memreq req;
92
	drm_sis_mem_t __user *argp = (void __user *)data;
93 94
	int retval = 0;

95
	DRM_COPY_FROM_USER_IOCTL(fb, argp, sizeof(fb));
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112

	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;
	}
113

114
	DRM_COPY_TO_USER_IOCTL(argp, fb, sizeof(fb));
115

116
	DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size, req.offset);
117 118

	return retval;
119 120
}

121
int sis_fb_free( DRM_IOCTL_ARGS )
122
{
123 124
	drm_sis_mem_t fb;
	int retval = 0;
125

126
	DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t __user *)data, sizeof(fb));
127

128 129 130 131 132
	if (!fb.free)
		return DRM_ERR(EINVAL);

	if (!del_alloc_set(fb.context, VIDEO_TYPE, fb.free))
		retval = DRM_ERR(EINVAL);
133
	sis_free((u32)fb.free);
134

135
	DRM_DEBUG("free fb, offset = %lu\n", fb.free);
136 137

	return retval;
138 139 140 141
}

#else

142 143 144 145 146 147 148 149 150 151 152
/* 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 )
153
{
154 155 156 157
	DRM_DEVICE;
	drm_sis_private_t *dev_priv = dev->dev_private;
	drm_sis_fb_t fb;

158
	DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_fb_t __user *)data, sizeof(fb));
159 160

	if (dev_priv == NULL) {
161
		dev->dev_private = drm_calloc(1, sizeof(drm_sis_private_t),
162 163 164 165 166 167 168 169 170 171 172 173 174 175
		    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;
176 177
}

178
int sis_fb_alloc( DRM_IOCTL_ARGS )
179
{
180 181
	DRM_DEVICE;
	drm_sis_private_t *dev_priv = dev->dev_private;
182
	drm_sis_mem_t __user *argp = (void __user *)data;
183 184 185 186 187 188 189
	drm_sis_mem_t fb;
	PMemBlock block;
	int retval = 0;

	if (dev_priv == NULL || dev_priv->FBHeap == NULL)
		return DRM_ERR(EINVAL);
  
190
	DRM_COPY_FROM_USER_IOCTL(fb, argp, sizeof(fb));
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
  
	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;
	}

208
	DRM_COPY_TO_USER_IOCTL(argp, fb, sizeof(fb));
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223

	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);

224
	DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t __user *)data, sizeof(fb));
225 226 227 228 229 230 231 232 233 234 235

	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;
236 237 238 239 240 241
}

#endif

/* agp memory management */ 

242
int sis_ioctl_agp_init( DRM_IOCTL_ARGS )
243
{
244 245 246 247 248
	DRM_DEVICE;
	drm_sis_private_t *dev_priv = dev->dev_private;
	drm_sis_agp_t agp;

	if (dev_priv == NULL) {
249
		dev->dev_private = drm_calloc(1, sizeof(drm_sis_private_t),
250 251 252 253 254 255 256 257 258
		    DRM_MEM_DRIVER);
		dev_priv = dev->dev_private;
		if (dev_priv == NULL)
			return ENOMEM;
	}

	if (dev_priv->AGPHeap != NULL)
		return DRM_ERR(EINVAL);

259
	DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_agp_t __user *)data, sizeof(agp));
260

261
	dev_priv->AGPHeap = mmInit(agp.offset, agp.size);
262

263
	DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);
264
  
265
	return 0;
266 267
}

268
int sis_ioctl_agp_alloc( DRM_IOCTL_ARGS )
269
{
270 271
	DRM_DEVICE;
	drm_sis_private_t *dev_priv = dev->dev_private;
272
	drm_sis_mem_t __user *argp = (void __user *)data;
273 274 275
	drm_sis_mem_t agp;
	PMemBlock block;
	int retval = 0;
276
   
277 278
	if (dev_priv == NULL || dev_priv->AGPHeap == NULL)
		return DRM_ERR(EINVAL);
279
  
280
	DRM_COPY_FROM_USER_IOCTL(agp, argp, sizeof(agp));
281
  
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
	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;
	}
297

298
	DRM_COPY_TO_USER_IOCTL(argp, agp, sizeof(agp));
299

300 301 302
	DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size, agp.offset);

	return retval;
303 304
}

305
int sis_ioctl_agp_free( DRM_IOCTL_ARGS )
306
{
307 308 309
	DRM_DEVICE;
	drm_sis_private_t *dev_priv = dev->dev_private;
	drm_sis_mem_t agp;
310

311 312
	if (dev_priv == NULL || dev_priv->AGPHeap == NULL)
		return DRM_ERR(EINVAL);
313

314
	DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_mem_t __user *)data, sizeof(agp));
315

316 317 318 319 320 321 322 323 324 325 326
	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;
}
327

328
int sis_init_context(struct drm_device *dev, int context)
329 330
{
	int i;
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354

	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;
		}
355 356 357 358 359
	}
	
	return 1;
}

360
int sis_final_context(struct drm_device *dev, int context)
361 362 363
{
	int i;

364 365 366 367 368
	for (i=0; i<MAX_CONTEXT; i++) {
		if (global_ppriv[i].used &&
		    (global_ppriv[i].context == context))
			break;
	}
369

370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
	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);
386
#endif
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
			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;	  
        }
403 404 405
	
	return 1;
}