Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 3768 → Rev 3769

/drivers/video/Intel-2D/gen3_render.c
1834,7 → 1834,7
 
static bool
gen3_blit_tex(struct sna *sna,
uint8_t op,
uint8_t op, bool scale,
PixmapPtr src, struct kgem_bo *src_bo,
PixmapPtr mask,struct kgem_bo *mask_bo,
PixmapPtr dst, struct kgem_bo *dst_bo,
1890,18 → 1890,20
tmp->mask.width = mask->drawable.width;
tmp->mask.height = mask->drawable.height;
 
tmp->src.scale[0] = 1.f/width; //src->width;
tmp->src.scale[1] = 1.f/height; //src->height;
// tmp->src.offset[0] = -dst_x;
// tmp->src.offset[1] = -dst_y;
if( scale )
{
tmp->src.scale[0] = 1.f/width;
tmp->src.scale[1] = 1.f/height;
}
else
{
tmp->src.scale[0] = 1.f/src->drawable.width;
tmp->src.scale[1] = 1.f/src->drawable.height;
}
 
 
tmp->mask.scale[0] = 1.f/mask->drawable.width;
tmp->mask.scale[1] = 1.f/mask->drawable.height;
// tmp->mask.offset[0] = -dst_x;
// tmp->mask.offset[1] = -dst_y;
 
 
tmp->prim_emit = gen3_emit_composite_primitive_identity_source_mask;
 
 
1952,7 → 1954,7
 
// render->video = gen3_render_video;
 
sna->render.blit_tex = gen3_blit_tex;
render->blit_tex = gen3_blit_tex;
 
render->reset = gen3_render_reset;
render->flush = gen3_render_flush;
1961,6 → 1963,8
render->max_3d_size = MAX_3D_SIZE;
render->max_3d_pitch = MAX_3D_PITCH;
 
render->caps = HW_BIT_BLIT | HW_TEX_BLIT;
 
sna->kgem.retire = gen3_render_retire;
sna->kgem.expire = gen3_render_expire;
return true;
/drivers/video/Intel-2D/gen4_render.c
1056,7 → 1056,7
 
static bool
gen4_blit_tex(struct sna *sna,
uint8_t op,
uint8_t op, bool scale,
PixmapPtr src, struct kgem_bo *src_bo,
PixmapPtr mask,struct kgem_bo *mask_bo,
PixmapPtr dst, struct kgem_bo *dst_bo,
1103,9 → 1103,16
tmp->mask.width = mask->drawable.width;
tmp->mask.height = mask->drawable.height;
 
 
tmp->src.scale[0] = 1.f/width; //src->width;
tmp->src.scale[1] = 1.f/height; //src->height;
if( scale )
{
tmp->src.scale[0] = 1.f/width;
tmp->src.scale[1] = 1.f/height;
}
else
{
tmp->src.scale[0] = 1.f/src->drawable.width;
tmp->src.scale[1] = 1.f/src->drawable.height;
}
// tmp->src.offset[0] = -dst_x;
// tmp->src.offset[1] = -dst_y;
 
/drivers/video/Intel-2D/gen5_render.c
989,7 → 989,7
 
static bool
gen5_blit_tex(struct sna *sna,
uint8_t op,
uint8_t op, bool scale,
PixmapPtr src, struct kgem_bo *src_bo,
PixmapPtr mask,struct kgem_bo *mask_bo,
PixmapPtr dst, struct kgem_bo *dst_bo,
1035,8 → 1035,16
tmp->mask.width = mask->drawable.width;
tmp->mask.height = mask->drawable.height;
 
tmp->src.scale[0] = 1.f/width; //src->width;
tmp->src.scale[1] = 1.f/height; //src->height;
if( scale )
{
tmp->src.scale[0] = 1.f/width;
tmp->src.scale[1] = 1.f/height;
}
else
{
tmp->src.scale[0] = 1.f/src->drawable.width;
tmp->src.scale[1] = 1.f/src->drawable.height;
}
 
tmp->mask.scale[0] = 1.f/mask->drawable.width;
tmp->mask.scale[1] = 1.f/mask->drawable.height;
/drivers/video/Intel-2D/gen6_render.c
2271,7 → 2271,6
}
#endif
 
#endif
 
static void
gen6_emit_copy_state(struct sna *sna,
2305,7 → 2304,6
gen6_emit_state(sna, op, offset | dirty);
}
 
#if 0
 
static inline bool prefer_blt_copy(struct sna *sna,
struct kgem_bo *src_bo,
2590,8 → 2588,6
box, n);
}
 
#endif
 
static void
gen6_render_copy_blt(struct sna *sna,
const struct sna_copy_op *op,
2677,11 → 2673,12
op->done = gen6_render_copy_done;
return true;
}
#endif
 
 
static bool
gen6_blit_tex(struct sna *sna,
uint8_t op,
uint8_t op, bool scale,
PixmapPtr src, struct kgem_bo *src_bo,
PixmapPtr mask,struct kgem_bo *mask_bo,
PixmapPtr dst, struct kgem_bo *dst_bo,
2734,8 → 2731,16
tmp->mask.height = mask->drawable.height;
 
 
tmp->src.scale[0] = 1.f/width; //src->width;
tmp->src.scale[1] = 1.f/height; //src->height;
if( scale )
{
tmp->src.scale[0] = 1.f/width;
tmp->src.scale[1] = 1.f/height;
}
else
{
tmp->src.scale[0] = 1.f/src->drawable.width;
tmp->src.scale[1] = 1.f/src->drawable.height;
}
// tmp->src.offset[0] = -dst_x;
// tmp->src.offset[1] = -dst_y;
 
/drivers/video/Intel-2D/gen7_render.c
1412,7 → 1412,7
 
static bool
gen7_blit_tex(struct sna *sna,
uint8_t op,
uint8_t op, bool scale,
PixmapPtr src, struct kgem_bo *src_bo,
PixmapPtr mask,struct kgem_bo *mask_bo,
PixmapPtr dst, struct kgem_bo *dst_bo,
1458,10 → 1458,17
tmp->mask.width = mask->drawable.width;
tmp->mask.height = mask->drawable.height;
 
if( scale )
{
tmp->src.scale[0] = 1.f/width;
tmp->src.scale[1] = 1.f/height;
}
else
{
tmp->src.scale[0] = 1.f/src->drawable.width;
tmp->src.scale[1] = 1.f/src->drawable.height;
}
 
tmp->src.scale[0] = 1.f/width; //src->width;
tmp->src.scale[1] = 1.f/height; //src->height;
 
tmp->mask.scale[0] = 1.f/mask->drawable.width;
tmp->mask.scale[1] = 1.f/mask->drawable.height;
 
/drivers/video/Intel-2D/kgem-sna.c
285,22 → 285,13
}
 
retry_mmap:
// ptr = mmap(0, bytes(bo), PROT_READ | PROT_WRITE, MAP_SHARED,
// kgem->fd, mmap_arg.offset);
// if (ptr == 0) {
ptr = (void*)(int)mmap_arg.offset;
if (ptr == NULL) {
printf("%s: failed to mmap %d, %d bytes, into GTT domain: %d\n",
__FUNCTION__, bo->handle, bytes(bo), 0);
// if (__kgem_throttle_retire(kgem, 0))
// goto retry_mmap;
 
// if (kgem->need_expire) {
// kgem_cleanup_cache(kgem);
// goto retry_mmap;
// }
}
 
ptr = NULL;
// }
 
return ptr;
}
 
650,7 → 641,6
 
static bool test_has_semaphores_enabled(struct kgem *kgem)
{
FILE *file;
bool detected = false;
int ret;
 
1128,7 → 1118,8
width = ALIGN(width, 2) * bpp >> 3;
return ALIGN(width, kgem_pitch_alignment(kgem, flags));
}
static uint32_t kgem_surface_size(struct kgem *kgem,
 
uint32_t kgem_surface_size(struct kgem *kgem,
bool relaxed_fencing,
unsigned flags,
uint32_t width,
4210,6 → 4201,45
return 1;
};
 
 
int kgem_update_fb(struct kgem *kgem, struct sna_fb *fb)
{
struct kgem_bo *bo;
size_t size;
int ret;
bo = fb->fb_bo;
ret = drmIoctl(kgem->fd, SRV_FBINFO, fb);
if( ret != 0 )
return 0;
 
fb->fb_bo = bo;
size = fb->pitch * fb->height / PAGE_SIZE;
 
if((size != bo->size.pages.count) ||
(fb->pitch != bo->pitch))
{
bo->size.pages.count = size;
bo->pitch = fb->pitch;
 
printf("fb width %d height %d pitch %d bo %p\n",
fb->width, fb->height, fb->pitch, fb->fb_bo);
return 1;
}
return 0;
};
 
void sna_bo_destroy(struct kgem *kgem, struct kgem_bo *bo)
{
kgem_bo_destroy(kgem, bo);
kgem_bo_free(kgem, bo);
}
 
 
void kgem_close_batches(struct kgem *kgem)
{
int n;
/drivers/video/Intel-2D/kgem.h
35,7 → 35,7
#include <stdarg.h>
#include <stdio.h>
 
#include "i915_drm.h"
#include <i915_drm.h>
 
#include "compiler.h"
#include "intel_list.h"
48,6 → 48,7
:"memory");
};
 
#undef DBG
 
#if HAS_DEBUG_FULL
#define DBG(x) printf x
/drivers/video/Intel-2D/sna.c
1,48 → 1,55
//#include "../bitmap.h"
 
 
#include <memory.h>
#include <malloc.h>
#include <kos32sys.h>
#include <pixlib2.h>
 
#include "sna.h"
 
#include <pixlib2.h>
#define to_surface(x) (surface_t*)((x)->handle)
 
static struct sna_fb sna_fb;
static struct kgem_bo *mask_bo;
static int tls_mask;
 
static int mask_width, mask_height;
int tls_alloc(void);
 
typedef struct __attribute__((packed))
static inline void *tls_get(int key)
{
unsigned handle;
unsigned io_code;
void *input;
int inp_size;
void *output;
int out_size;
}ioctl_t;
void *val;
__asm__ __volatile__(
"movl %%fs:(%1), %0"
:"=r"(val)
:"r"(key));
 
 
static int call_service(ioctl_t *io)
{
int retval;
 
asm volatile("int $0x40"
:"=a"(retval)
:"a"(68),"b"(17),"c"(io)
:"memory","cc");
 
return retval;
return val;
};
 
static inline void get_proc_info(char *info)
static inline int
tls_set(int key, const void *ptr)
{
if(!(key & 3))
{
__asm__ __volatile__(
"int $0x40"
:
:"a"(9), "b"(info), "c"(-1));
"movl %0, %%fs:(%1)"
::"r"(ptr),"r"(key));
return 0;
}
else return -1;
}
 
 
 
 
int kgem_init_fb(struct kgem *kgem, struct sna_fb *fb);
int kgem_update_fb(struct kgem *kgem, struct sna_fb *fb);
uint32_t kgem_surface_size(struct kgem *kgem,bool relaxed_fencing,
unsigned flags, uint32_t width, uint32_t height,
uint32_t bpp, uint32_t tiling, uint32_t *pitch);
 
void kgem_close_batches(struct kgem *kgem);
void sna_bo_destroy(struct kgem *kgem, struct kgem_bo *bo);
 
const struct intel_device_info *
intel_detect_chipset(struct pci_device *pci);
 
52,6 → 59,8
 
struct sna *sna_device;
 
__LOCK_INIT_RECURSIVE(, __sna_lock);
 
static void no_render_reset(struct sna *sna)
{
(void)sna;
149,6 → 158,7
int sna_init(uint32_t service)
{
ioctl_t io;
int caps = 0;
 
static struct pci_device device;
struct sna *sna;
155,11 → 165,10
 
DBG(("%s\n", __FUNCTION__));
 
sna = malloc(sizeof(*sna));
if (sna == NULL)
return 0;
__lock_acquire_recursive(__sna_lock);
 
memset(sna, 0, sizeof(*sna));
if(sna_device)
goto done;
io.handle = service;
io.io_code = SRV_GET_PCI_INFO;
169,11 → 178,14
io.out_size = 0;
 
if (call_service(&io)!=0)
{
free(sna);
return 0;
};
goto err1;
sna = malloc(sizeof(*sna));
if (sna == NULL)
goto err1;
 
memset(sna, 0, sizeof(*sna));
sna->PciInfo = &device;
 
sna->info = intel_detect_chipset(sna->PciInfo);
209,9 → 221,17
 
sna_accel_init(sna);
 
delay(10);
tls_mask = tls_alloc();
return sna->render.caps;
// printf("tls mask %x\n", tls_mask);
done:
caps = sna_device->render.caps;
 
err1:
__lock_release_recursive(__sna_lock);
return caps;
}
 
void sna_fini()
218,10 → 238,20
{
if( sna_device )
{
struct kgem_bo *mask;
__lock_acquire_recursive(__sna_lock);
mask = tls_get(tls_mask);
sna_device->render.fini(sna_device);
kgem_bo_destroy(&sna_device->kgem, mask_bo);
if(mask)
kgem_bo_destroy(&sna_device->kgem, mask);
kgem_close_batches(&sna_device->kgem);
kgem_cleanup_cache(&sna_device->kgem);
sna_device = NULL;
__lock_release_recursive(__sna_lock);
};
}
 
354,6 → 384,7
return kgem_bo_reference(cache->bo[i]);
}
 
#endif
 
 
int sna_blit_copy(bitmap_t *src_bitmap, int dst_x, int dst_y,
397,72 → 428,181
 
kgem_submit(&sna_device->kgem);
return 0;
// __asm__ __volatile__("int3");
};
#endif
 
typedef struct
{
uint32_t width;
uint32_t height;
void *data;
uint32_t pitch;
struct kgem_bo *bo;
uint32_t bo_size;
uint32_t flags;
}surface_t;
 
 
 
int sna_create_bitmap(bitmap_t *bitmap)
{
surface_t *sf;
struct kgem_bo *bo;
sf = malloc(sizeof(*sf));
if(sf == NULL)
goto err_1;
__lock_acquire_recursive(__sna_lock);
 
bo = kgem_create_2d(&sna_device->kgem, bitmap->width, bitmap->height,
32,I915_TILING_NONE, CREATE_CPU_MAP);
if(bo == NULL)
goto err_1;
goto err_2;
void *map = kgem_bo_map(&sna_device->kgem, bo);
if(map == NULL)
goto err_2;
goto err_3;
bitmap->handle = (uint32_t)bo;
bitmap->pitch = bo->pitch;
bitmap->data = map;
sf->width = bitmap->width;
sf->height = bitmap->height;
sf->data = map;
sf->pitch = bo->pitch;
sf->bo = bo;
sf->bo_size = PAGE_SIZE * bo->size.pages.count;
sf->flags = bitmap->flags;
bitmap->handle = (uint32_t)sf;
__lock_release_recursive(__sna_lock);
return 0;
err_3:
kgem_bo_destroy(&sna_device->kgem, bo);
err_2:
kgem_bo_destroy(&sna_device->kgem, bo);
__lock_release_recursive(__sna_lock);
free(sf);
err_1:
return -1;
};
int sna_destroy_bitmap(bitmap_t *bitmap)
{
surface_t *sf = to_surface(bitmap);
__lock_acquire_recursive(__sna_lock);
kgem_bo_destroy(&sna_device->kgem, sf->bo);
__lock_release_recursive(__sna_lock);
 
free(sf);
bitmap->handle = -1;
bitmap->data = (void*)-1;
bitmap->pitch = -1;
 
return 0;
};
 
void sna_destroy_bitmap(bitmap_t *bitmap)
int sna_lock_bitmap(bitmap_t *bitmap)
{
struct kgem_bo *bo;
surface_t *sf = to_surface(bitmap);
bo = (struct kgem_bo *)bitmap->handle;
// printf("%s\n", __FUNCTION__);
__lock_acquire_recursive(__sna_lock);
kgem_bo_destroy(&sna_device->kgem, bo);
kgem_bo_sync__cpu(&sna_device->kgem, sf->bo);
 
__lock_release_recursive(__sna_lock);
bitmap->data = sf->data;
bitmap->pitch = sf->pitch;
 
return 0;
};
 
void sna_lock_bitmap(bitmap_t *bitmap)
int sna_resize_bitmap(bitmap_t *bitmap)
{
struct kgem_bo *bo;
surface_t *sf = to_surface(bitmap);
struct kgem *kgem = &sna_device->kgem;
struct kgem_bo *bo = sf->bo;
bo = (struct kgem_bo *)bitmap->handle;
uint32_t size;
uint32_t pitch;
kgem_bo_sync__cpu(&sna_device->kgem, bo);
bitmap->pitch = -1;
bitmap->data = (void *) -1;
 
size = kgem_surface_size(kgem,kgem->has_relaxed_fencing, CREATE_CPU_MAP,
bitmap->width, bitmap->height, 32, I915_TILING_NONE, &pitch);
assert(size && size <= kgem->max_object_size);
if(sf->bo_size >= size)
{
sf->width = bitmap->width;
sf->height = bitmap->height;
sf->pitch = pitch;
bo->pitch = pitch;
return 0;
}
else
{
__lock_acquire_recursive(__sna_lock);
sna_bo_destroy(kgem, bo);
sf->bo = NULL;
bo = kgem_create_2d(kgem, bitmap->width, bitmap->height,
32, I915_TILING_NONE, CREATE_CPU_MAP);
 
if(bo == NULL)
{
__lock_release_recursive(__sna_lock);
return -1;
};
 
void *map = kgem_bo_map(kgem, bo);
if(map == NULL)
{
sna_bo_destroy(kgem, bo);
__lock_release_recursive(__sna_lock);
return -1;
};
__lock_release_recursive(__sna_lock);
sf->width = bitmap->width;
sf->height = bitmap->height;
sf->data = map;
sf->pitch = bo->pitch;
sf->bo = bo;
sf->bo_size = PAGE_SIZE * bo->size.pages.count;
}
 
return 0;
};
 
 
 
int sna_create_mask()
{
struct kgem_bo *bo;
int width, height;
int i;
 
// printf("%s width %d height %d\n", __FUNCTION__, sna_fb.width, sna_fb.height);
__lock_acquire_recursive(__sna_lock);
bo = kgem_create_2d(&sna_device->kgem, sna_fb.width, sna_fb.height,
8,I915_TILING_NONE, CREATE_CPU_MAP);
if(bo == NULL)
if(unlikely(bo == NULL))
goto err_1;
int *map = kgem_bo_map(&sna_device->kgem, bo);
469,20 → 609,19
if(map == NULL)
goto err_2;
memset(map, 0, bo->pitch * height);
__lock_release_recursive(__sna_lock);
mask_bo = bo;
mask_width = width;
mask_height = height;
memset(map, 0, bo->pitch * sna_fb.height);
tls_set(tls_mask, bo);
return 0;
err_2:
kgem_bo_destroy(&sna_device->kgem, bo);
err_1:
__lock_release_recursive(__sna_lock);
return -1;
};
 
 
501,39 → 640,52
 
#define MAP(ptr) ((void*)((uintptr_t)(ptr) & ~3))
 
int sna_blit_tex(bitmap_t *src_bitmap, int dst_x, int dst_y,
int sna_blit_tex(bitmap_t *bitmap, bool scale, int dst_x, int dst_y,
int w, int h, int src_x, int src_y)
 
{
surface_t *sf = to_surface(bitmap);
 
// box.x1 = dst_x;
// box.y1 = dst_y;
// box.x2 = dst_x+w;
// box.y2 = dst_y+h;
 
 
// cop.box(sna_device, &cop, &box);
 
struct drm_i915_mask_update update;
struct sna_composite_op composite;
struct _Pixmap src, dst, mask;
struct kgem_bo *src_bo;
struct kgem_bo *src_bo, *mask_bo;
int winx, winy;
 
char proc_info[1024];
int winx, winy, winw, winh;
 
get_proc_info(proc_info);
 
winx = *(uint32_t*)(proc_info+34);
winy = *(uint32_t*)(proc_info+38);
winw = *(uint32_t*)(proc_info+42)+1;
winh = *(uint32_t*)(proc_info+46)+1;
// winw = *(uint32_t*)(proc_info+42)+1;
// winh = *(uint32_t*)(proc_info+46)+1;
mask_bo = tls_get(tls_mask);
if(unlikely(mask_bo == NULL))
{
sna_create_mask();
mask_bo = tls_get(tls_mask);
if( mask_bo == NULL)
return -1;
};
if(kgem_update_fb(&sna_device->kgem, &sna_fb))
{
__lock_acquire_recursive(__sna_lock);
kgem_bo_destroy(&sna_device->kgem, mask_bo);
__lock_release_recursive(__sna_lock);
sna_create_mask();
mask_bo = tls_get(tls_mask);
if( mask_bo == NULL)
return -1;
}
VG_CLEAR(update);
update.handle = mask_bo->handle;
// update.bo_size = __kgem_bo_size(mask_bo);
// update.bo_pitch = mask_bo->pitch;
update.bo_map = (__u32)MAP(mask_bo->map);
drmIoctl(sna_device->kgem.fd, SRV_MASK_UPDATE, &update);
mask_bo->pitch = update.bo_pitch;
543,9 → 695,10
memset(&mask, 0, sizeof(dst));
 
src.drawable.bitsPerPixel = 32;
src.drawable.width = src_bitmap->width;
src.drawable.height = src_bitmap->height;
 
src.drawable.width = sf->width;
src.drawable.height = sf->height;
 
dst.drawable.bitsPerPixel = 32;
dst.drawable.width = sna_fb.width;
dst.drawable.height = sna_fb.height;
556,10 → 709,12
 
memset(&composite, 0, sizeof(composite));
 
src_bo = (struct kgem_bo*)src_bitmap->handle;
src_bo = sf->bo;
__lock_acquire_recursive(__sna_lock);
if( sna_device->render.blit_tex(sna_device, PictOpSrc,
if( sna_device->render.blit_tex(sna_device, PictOpSrc,scale,
&src, src_bo,
&mask, mask_bo,
&dst, sna_fb.fb_bo,
582,10 → 737,16
composite.blt(sna_device, &composite, &r);
composite.done(sna_device, &composite);
};
kgem_submit(&sna_device->kgem);
__lock_release_recursive(__sna_lock);
 
bitmap->data = (void*)-1;
bitmap->pitch = -1;
return 0;
}
 
758,8 → 919,6
intel_detect_chipset(struct pci_device *pci)
{
const struct pci_id_match *ent = NULL;
const char *name = NULL;
int i;
 
ent = PciDevMatch(pci->device_id, intel_device_match);
/drivers/video/Intel-2D/sna.h
60,27 → 60,6
int drmIoctl(int fd, unsigned long request, void *arg);
 
 
#define SRV_GET_PCI_INFO 20
#define SRV_GET_PARAM 21
#define SRV_I915_GEM_CREATE 22
#define SRV_DRM_GEM_CLOSE 23
#define SRV_I915_GEM_PIN 24
#define SRV_I915_GEM_SET_CACHEING 25
#define SRV_I915_GEM_GET_APERTURE 26
#define SRV_I915_GEM_PWRITE 27
#define SRV_I915_GEM_BUSY 28
#define SRV_I915_GEM_SET_DOMAIN 29
#define SRV_I915_GEM_MMAP 30
#define SRV_I915_GEM_THROTTLE 32
#define SRV_FBINFO 33
#define SRV_I915_GEM_EXECBUFFER2 34
#define SRV_MASK_UPDATE 35
 
#define SRV_I915_GEM_MMAP_GTT 31
 
 
#define DRM_IOCTL_GEM_CLOSE SRV_DRM_GEM_CLOSE
 
#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) | \
((type) << 16) | \
((a) << 12) | \
/drivers/video/Intel-2D/sna_render.h
223,7 → 223,7
#endif
 
bool (*blit_tex)(struct sna *sna,
uint8_t op,
uint8_t op, bool scale,
PixmapPtr src, struct kgem_bo *src_bo,
PixmapPtr mask,struct kgem_bo *mask_bo,
PixmapPtr dst, struct kgem_bo *dst_bo,