Subversion Repositories Kolibri OS

Compare Revisions

Ignore whitespace Rev 3038 → Rev 3039

/drivers/ddk/core.S
62,6 → 62,7
.global _TimerHs
 
.global _UserAlloc
.global _UserFree
 
.global _WaitEvent
 
123,6 → 124,7
.def _TimerHs; .scl 2; .type 32; .endef
 
.def _UserAlloc; .scl 2; .type 32; .endef
.def _UserFree; .scl 2; .type 32; .endef
 
.def _WaitEvent; .scl 2; .type 32; .endef
 
185,6 → 187,7
_TimerHs:
 
_UserAlloc:
_UserFree:
_WaitEvent:
 
ret
252,6 → 255,7
.ascii " -export:TimerHs" # stdcall
 
.ascii " -export:UserAlloc" # stdcall
.ascii " -export:UserFree" # stdcall
 
.ascii " -export:WaitEvent" # stdcall
 
/drivers/ddk/malloc/malloc.c
89,9 → 89,9
#define NO_SEGMENT_TRAVERSAL 1
#define MALLOC_ALIGNMENT ((size_t)8U)
#define CHUNK_OVERHEAD (SIZE_T_SIZE)
#define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U)
#define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)
#define DEFAULT_TRIM_THRESHOLD ((size_t)512U * (size_t)1024U)
#define DEFAULT_GRANULARITY ((size_t)128U * (size_t)1024U)
#define DEFAULT_MMAP_THRESHOLD ((size_t)512U * (size_t)1024U)
#define DEFAULT_TRIM_THRESHOLD ((size_t)1024U * (size_t)1024U)
 
/* The bit mask value corresponding to MALLOC_ALIGNMENT */
#define CHUNK_ALIGN_MASK (MALLOC_ALIGNMENT - SIZE_T_ONE)
835,6 → 835,7
static inline void* os_mmap(size_t size)
{
void* ptr = KernelAlloc(size);
printf("%s %x %d bytes\n",__FUNCTION__, ptr, size);
return (ptr != 0)? ptr: MFAIL;
}
 
1110,6 → 1111,8
 
ensure_initialization();
 
printf("%s %d bytes\n", __FUNCTION__, nb);
 
/* Directly map large chunks, but only if already initialized */
if (use_mmap(m) && nb >= mparams.mmap_threshold && m->topsize != 0)
{
/drivers/include/linux/kernel.h
36,7 → 36,13
#define PTR_ALIGN(p, a) ((typeof(p))ALIGN((unsigned long)(p), (a)))
#define IS_ALIGNED(x, a) (((x) & ((typeof(x))(a) - 1)) == 0)
 
#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
/* The `const' in roundup() prevents gcc-3.3 from calling __divdi3 */
#define roundup(x, y) ( \
{ \
const typeof(y) __y = y; \
(((x) + (__y - 1)) / __y) * __y; \
} \
)
 
#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
#define DIV_ROUND_CLOSEST(x, divisor)( \
/drivers/video/drm/i915/bitmap.c
36,7 → 36,7
for (i = 0; i < bitmap->page_count; i++)
FreePage(pages[i]);
 
DRM_DEBUG("%s freec %d pages\n", __FUNCTION__, bitmap->page_count);
DRM_DEBUG("%s release %d pages\n", __FUNCTION__, bitmap->page_count);
 
free(pages);
};
52,6 → 52,7
/* Get the list of pages out of our struct file. They'll be pinned
* at this point until we release them.
*/
 
page_count = obj->base.size / PAGE_SIZE;
BUG_ON(obj->allocated_pages == NULL);
BUG_ON(obj->pages.page != NULL);
305,8 → 306,107
};
 
 
int resize_surface(struct io_call_14 *pbitmap)
{
bitmap_t *bitmap;
dma_addr_t page, *pages;
u32 size, page_count;
u32 width, height;
u32 pitch;
int i;
int ret = 0;
 
 
if(unlikely(pbitmap->handle == 0))
return -1;
 
bitmap = (bitmap_t*)hmm_get_data(&bm_mm, pbitmap->handle);
 
if(unlikely(bitmap==NULL))
return -1;
 
if( pbitmap->new_width > bitmap->max_width ||
pbitmap->new_height > bitmap->max_height)
return -1;
 
width = pbitmap->new_width;
height = pbitmap->new_height;
 
pitch = ALIGN(width*4,64);
size = roundup(pitch * height, PAGE_SIZE);
page_count = size/PAGE_SIZE;
 
DRM_DEBUG("new width %d height %d pitch %d size %d\n",
width, height, pitch, size);
 
if( page_count == bitmap->page_count )
{
bitmap->width = width;
bitmap->height = height;
bitmap->pitch = pitch;
}
else if(page_count > bitmap->page_count)
{
char *vaddr = bitmap->uaddr + PAGE_SIZE * bitmap->page_count;
 
pages = bitmap->obj->allocated_pages;
 
DRM_DEBUG("old pages %d new_pages %d vaddr %x\n",
bitmap->page_count, page_count, vaddr);
 
for(i = bitmap->page_count; i < page_count; i++, vaddr+= PAGE_SIZE)
{
page = AllocPage();
if ( page == 0 )
goto err4;
pages[i] = page;
MapPage(vaddr, page, 0x207); //map as shared page
};
 
DRM_DEBUG("%s alloc %d pages\n", __FUNCTION__,
page_count - bitmap->page_count);
 
// mutex_lock(&main_device->struct_mutex);
 
i915_gem_object_unpin(bitmap->obj);
i915_gem_object_unbind(bitmap->obj);
bitmap->obj->base.size = size;
bitmap->obj->pages.nents = page_count;
 
ret = i915_gem_object_pin(bitmap->obj, PAGE_SIZE, true,true);
if (ret)
goto err4;
// mutex_unlock(&main_device->struct_mutex);
 
bitmap->page_count = page_count;
bitmap->width = width;
bitmap->height = height;
bitmap->pitch = pitch;
bitmap->gaddr = bitmap->obj->gtt_offset;
};
 
if(ret != 0 )
{
pbitmap->data = NULL;
pbitmap->pitch = 0;
 
dbgprintf("%s fail\n", __FUNCTION__);
return ret;
};
 
pbitmap->data = bitmap->uaddr;
pbitmap->pitch = bitmap->pitch;
 
return 0;
 
err4:
while (i-- > bitmap->page_count)
FreePage(pages[i]);
 
return -1;
};
 
 
int init_bitmaps()
{
int ret;
/drivers/video/drm/i915/bitmap.h
17,7 → 17,7
kobj_t header;
 
u32 handle;
void *uaddr;
char *uaddr;
 
u32 pitch;
u32 gaddr;
50,15 → 50,20
 
struct io_call_12 /* SRV_LOCK_SURFACE */
{
u32 handle; // ignored
void *data; // ignored
u32 handle;
void *data;
u32 pitch;
};
 
u32 width;
u32 height;
u32 pitch; // ignored
struct io_call_14 /* SRV_RESIZE_SURFACE */
{
u32 handle;
void *data;
u32 new_width;
u32 new_height;
u32 pitch;
};
 
 
typedef struct
{
uint32_t idx;
93,6 → 98,7
int get_driver_caps(hwcaps_t *caps);
int create_surface(struct drm_device *dev, struct io_call_10 *pbitmap);
int lock_surface(struct io_call_12 *pbitmap);
int resize_surface(struct io_call_14 *pbitmap);
 
struct context *get_context(struct drm_device *dev);
 
/drivers/video/drm/i915/i915_gem.c
1409,7 → 1409,7
for (i = 0; i < obj->pages.nents; i++)
FreePage(obj->pages.page[i]);
 
DRM_DEBUG_KMS("%s free %d pages\n", __FUNCTION__, obj->pages.nents);
DRM_DEBUG_KMS("%s release %d pages\n", __FUNCTION__, obj->pages.nents);
obj->dirty = 0;
kfree(obj->pages.page);
}
1419,6 → 1419,9
{
const struct drm_i915_gem_object_ops *ops = obj->ops;
 
// printf("page %x pin count %d\n",
// obj->pages.page, obj->pages_pin_count );
 
if (obj->pages.page == NULL)
return 0;
 
/drivers/video/drm/i915/kms_display.c
716,8 → 716,8
 
dst_clip.xmin = 0;
dst_clip.ymin = 0;
dst_clip.xmax = winrc.right-winrc.left-1;
dst_clip.ymax = winrc.bottom -winrc.top-1;
dst_clip.xmax = winrc.right-winrc.left;
dst_clip.ymax = winrc.bottom -winrc.top;
 
src_clip.xmin = 0;
src_clip.ymin = 0;
869,7 → 869,7
b[n++] = cmd;
b[n++] = br13;
b[n++] = (dst_y << 16) | dst_x; // left, top
b[n++] = ((dst_y+height-1)<< 16)|(dst_x+width-1); // bottom, right
b[n++] = ((dst_y+height)<< 16)|(dst_x+width); // bottom, right
b[n++] = 0; // destination
b[n++] = (src_y << 16) | src_x; // source left & top
b[n++] = bitmap->pitch; // source pitch
/drivers/video/drm/i915/main.c
100,7 → 100,9
#define SRV_DESTROY_SURFACE 11
#define SRV_LOCK_SURFACE 12
#define SRV_UNLOCK_SURFACE 13
#define SRV_RESIZE_SURFACE 14
 
 
#define SRV_BLIT_VIDEO 20
 
#define check_input(size) \
158,6 → 160,10
retval = lock_surface((struct io_call_12*)inp);
break;
 
case SRV_RESIZE_SURFACE:
retval = resize_surface((struct io_call_14*)inp);
break;
 
case SRV_BLIT_VIDEO:
blit_video( inp[0], inp[1], inp[2],
inp[3], inp[4], inp[5], inp[6]);