Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 4371 → Rev 4372

/contrib/sdk/sources/Intel-2D/pixlib_sna.c
File deleted
/contrib/sdk/sources/Intel-2D/Makefile
0,0 → 1,101
 
LIBRARY= pixlib
 
CC=gcc
CFLAGS = -U_Win32 -U_WIN32 -U__MINGW32__ -c -O2 -fomit-frame-pointer
 
LD = ld
 
AR= ar
 
STRIP = $(PREFIX)strip
 
LDFLAGS:= -shared -s -nostdlib -T ../newlib/dll.lds --entry _DllStartup --image-base=0
PXFLAGS:= --version-script pixlib.ver --output-def $(LIBRARY).orig.def --out-implib $(LIBRARY).dll.a
SNAFLAGS:= --version-script sna.ver --output-def sna.def
INCLUDES= -I. -I../libdrm/intel -I../libdrm/include/drm -I./render_program -I../pixman -I../newlib/include
 
LIBPATH:= -L../../lib
 
LIBS:= -ldll -lc.dll
 
DEFINES:= -DHAS_DEBUG_FULL=0 -DSHOW_BATCH=0 -DDEBUG_DUMP=0
 
 
SRC_PIXLIB = pixlib.c
 
SRC_SNA = sna/gen3_render.c \
sna/gen4_render.c \
sna/gen4_vertex.c \
sna/gen5_render.c \
sna/gen6_render.c \
sna/gen7_render.c \
sna/kgem.c \
sna/sna.c \
sna/sna_cpu.c \
sna/sna_stream.c \
sna/sna_transform.c \
sna/utils.c \
sna/brw/brw_eu.c \
sna/brw/brw_eu_emit.c \
sna/brw/brw_sf.c \
sna/brw/brw_wm.c
 
SRC_UXA = pixlib_uxa.c \
uxa/uxa.c \
uxa/i965_3d.c \
uxa/i965_render.c \
uxa/intel_batchbuffer.c
 
OBJ_PIXLIB = $(patsubst %.c, %.o, $(SRC_PIXLIB))
OBJ_UXA = $(patsubst %.c, %.o, $(SRC_UXA))
OBJ_SNA = $(patsubst %.c, %.o, $(SRC_SNA))
ifeq ($(findstring ebox,$(MAKECMDGOALS)),ebox)
CFLAGS+=-march=pentium-mmx
DEFINES+= -DBUILD_EBOX
else
LIBS+= -ldrm.dll
ifeq ($(findstring uxa,$(MAKECMDGOALS)),uxa)
OBJECTS= $(OBJ_UXA)
DEFINES+= -DBUILD_UXA
else
OBJECTS= $(OBJ_SNA)
DEFINES+= -DBUILD_SNA
LIBS+= -lgcc
endif
endif
 
# targets
 
all:$(LIBRARY).dll intel-sna.drv intel-uxa.drv
uxa:$(LIBRARY).dll
ebox:$(LIBRARY).dll
 
 
$(LIBRARY).dll: $(OBJ_PIXLIB) Makefile
$(LD) $(LDFLAGS) $(PXFLAGS) $(LIBPATH) -o $@ $(OBJ_PIXLIB) $(LIBS)
$(STRIP) $@
mv -f $@ ../../bin
mv -f $(LIBRARY).dll.a ../../lib
 
intel-sna.drv: $(OBJ_SNA) Makefile
$(LD) $(LDFLAGS) $(SNAFLAGS) $(LIBPATH) -o $@ $(OBJ_SNA) $(LIBS)
$(STRIP) $@
mv -f $@ ../../bin
 
intel-uxa.drv: $(OBJ_UXA) Makefile
$(LD) $(LDFLAGS) $(LIBPATH) -o $@ $(OBJ_UXA) $(LIBS)
$(STRIP) $@
mv -f $@ ../../bin
%.o : %.c Makefile
$(CC) $(CFLAGS) $(DEFINES) $(INCLUDES) -o $@ $<
 
clean:
-rm -f *.o
 
 
 
 
/contrib/sdk/sources/Intel-2D/pixlib.c
0,0 → 1,298
 
// -kr -i4 -ts4 -bls -bl -bli0
 
#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>
#include <pixlib2.h>
#include <kos32sys.h>
 
void* load_library(const char *name);
 
struct pix_driver
{
char *name;
 
int (*create_bitmap)(bitmap_t * bitmap);
int (*destroy_bitmap)(bitmap_t * bitmap);
int (*lock_bitmap)(bitmap_t * bitmap);
int (*blit)(bitmap_t * bitmap, bool scale, int dst_x, int dst_y,
int w, int h, int src_x, int src_y);
int (*resize_bitmap)(bitmap_t * bitmap);
void (*fini)(void);
};
 
#define DISPLAY_VERSION 0x0200 /* 2.00 */
 
#define SRV_GETVERSION 0
#define SRV_GET_CAPS 3
 
#define BUFFER_SIZE(n) ((n)*sizeof(uint32_t))
#define __ALIGN_MASK(x,mask) (((x)+(mask))&~(mask))
#define ALIGN(x,a) __ALIGN_MASK(x,(typeof(x))(a)-1)
 
#define to_surface(x) (surface_t*)((x)->handle)
 
typedef struct
{
uint32_t width;
uint32_t height;
void *data;
uint32_t pitch;
uint32_t bo;
uint32_t bo_size;
uint32_t flags;
} surface_t;
 
static uint32_t service;
static uint32_t hw_caps;
static struct pix_driver pix_driver;
 
uint32_t init_pixlib(uint32_t caps)
{
void *lib;
uint32_t (*drventry)(uint32_t service, struct pix_driver *driver);
 
uint32_t api_version;
ioctl_t io;
 
if (service != 0)
return caps & hw_caps;
 
service = get_service("DISPLAY");
if (service == 0)
goto fail;
 
io.handle = service;
io.io_code = SRV_GETVERSION;
io.input = NULL;
io.inp_size = 0;
io.output = &api_version;
io.out_size = BUFFER_SIZE(1);
 
if (call_service(&io) != 0)
goto fail;
 
if ((DISPLAY_VERSION > (api_version & 0xFFFF)) ||
(DISPLAY_VERSION < (api_version >> 16)))
goto fail;
 
lib = load_library("intel-sna.drv");
if(lib == 0)
lib = load_library("intel-uxa.drv");
if(lib == 0)
goto fail;
 
drventry = get_proc_address(lib, "DrvInit");
 
if( drventry == NULL)
goto fail;
 
hw_caps = drventry(service, &pix_driver);
 
if (hw_caps)
printf("2D caps %s%s%s\n",
(hw_caps & HW_BIT_BLIT) != 0 ? "HW_BIT_BLIT " : "",
(hw_caps & HW_TEX_BLIT) != 0 ? "HW_TEX_BLIT " : "",
(hw_caps & HW_VID_BLIT) != 0 ? "HW_VID_BLIT " : "");
 
return caps & hw_caps;
 
fail:
service = 0;
return 0;
};
 
void done_pixlib()
{
if (hw_caps != 0)
pix_driver.fini();
};
 
int create_bitmap(bitmap_t * bitmap)
{
uint32_t size, bo_size;
uint32_t pitch, max_pitch;
void *buffer;
surface_t *sf;
 
bitmap->handle = -1;
bitmap->data = (void *) -1;
bitmap->pitch = -1;
 
if (bitmap->flags &= hw_caps)
return pix_driver.create_bitmap(bitmap);
 
pitch = ALIGN(bitmap->width * 4, 16);
max_pitch = ALIGN(bitmap->max_width * 4, 16);
 
size = ALIGN(pitch * bitmap->height, 4096);
bo_size = ALIGN(max_pitch * bitmap->max_height, 4096);
 
if (bo_size < size)
bo_size = size;
 
sf = malloc(sizeof(*sf));
if (sf == NULL)
return -1;
 
buffer = user_alloc(bo_size);
 
if (buffer == NULL)
{
free(sf);
return -1;
};
 
sf->width = bitmap->width;
sf->height = bitmap->height;
sf->data = buffer;
sf->pitch = pitch;
sf->bo = 0;
sf->bo_size = bo_size;
sf->flags = bitmap->flags;
 
bitmap->handle = (uint32_t) sf;
 
// printf("create bitmap %p handle %p data %p w %d h%d\n",
// bitmap, bitmap->handle, bitmap->data, bitmap->width, bitmap->height);
 
return 0;
};
 
int destroy_bitmap(bitmap_t * bitmap)
{
surface_t *sf = to_surface(bitmap);
 
if (sf->flags & hw_caps)
return pix_driver.destroy_bitmap(bitmap);
 
user_free(sf->data);
free(sf);
 
bitmap->handle = -1;
bitmap->data = (void *) -1;
bitmap->pitch = -1;
 
return 0;
};
 
int lock_bitmap(bitmap_t * bitmap)
{
surface_t *sf = to_surface(bitmap);
 
if (bitmap->data != (void *) -1)
return 0;
 
if (sf->flags & hw_caps)
return pix_driver.lock_bitmap(bitmap);
 
bitmap->data = sf->data;
bitmap->pitch = sf->pitch;
 
return 0;
};
 
int blit_bitmap(bitmap_t * bitmap, int dst_x, int dst_y,
int w, int h, int src_x, int src_y)
{
struct blit_call bc;
int ret;
 
surface_t *sf = to_surface(bitmap);
 
if (sf->flags & hw_caps & HW_BIT_BLIT)
return pix_driver.blit(bitmap, false, dst_x, dst_y, w, h, src_x, src_y);
 
bc.dstx = dst_x;
bc.dsty = dst_y;
bc.w = w;
bc.h = h;
bc.srcx = 0;
bc.srcy = 0;
bc.srcw = w;
bc.srch = h;
bc.stride = sf->pitch;
bc.bitmap = sf->data;
 
__asm__ __volatile__(
"int $0x40":"=a"(ret):"a"(73), "b"(0x00),
"c"(&bc):"memory");
 
bitmap->data = (void *) -1;
bitmap->pitch = -1;
 
return ret;
};
 
int fplay_blit_bitmap(bitmap_t * bitmap, int dst_x, int dst_y, int w, int h)
{
struct blit_call bc;
int ret;
 
surface_t *sf = to_surface(bitmap);
 
if (sf->flags & hw_caps & HW_TEX_BLIT)
return pix_driver.blit(bitmap, true, dst_x, dst_y, w, h, 0, 0);
 
bc.dstx = dst_x;
bc.dsty = dst_y;
bc.w = w;
bc.h = h;
bc.srcx = 0;
bc.srcy = 0;
bc.srcw = w;
bc.srch = h;
bc.stride = sf->pitch;
bc.bitmap = sf->data;
 
__asm__ __volatile__(
"int $0x40":"=a"(ret):"a"(73), "b"(0x00),
"c"(&bc):"memory");
 
bitmap->data = (void *) -1;
bitmap->pitch = -1;
 
return ret;
};
 
int resize_bitmap(bitmap_t * bitmap)
{
uint32_t size;
uint32_t pitch;
 
// printf("%s\n", __FUNCTION__);
 
surface_t *sf = to_surface(bitmap);
 
if (sf->flags & hw_caps)
return pix_driver.resize_bitmap(bitmap);
 
pitch = ALIGN(bitmap->width * 4, 16);
size = ALIGN(pitch * bitmap->height, 4096);
 
bitmap->pitch = -1;
bitmap->data = (void *) -1;
 
if (size > sf->bo_size)
{
sf->data = user_realloc(sf->data, size); /* grow buffer */
if (sf->data == NULL)
return -1;
 
sf->bo_size = size;
} else if (size < sf->bo_size)
user_unmap(sf->data, size, sf->bo_size - size); /* unmap unused pages */
 
sf->width = bitmap->width;
sf->height = bitmap->height;
sf->pitch = pitch;
 
return 0;
};
 
int sna_create_mask()
{
return 0;
}
 
/contrib/sdk/sources/Intel-2D/sna/sna.c
56,6 → 56,20
int b;
} rect_t;
 
struct pix_driver
{
char *name;
 
int (*create_bitmap)(bitmap_t * bitmap);
int (*destroy_bitmap)(bitmap_t * bitmap);
int (*lock_bitmap)(bitmap_t * bitmap);
int (*blit)(bitmap_t * bitmap, bool scale, int dst_x, int dst_y,
int w, int h, int src_x, int src_y);
int (*resize_bitmap)(bitmap_t * bitmap);
void (*fini)(void);
};
 
 
static struct sna_fb sna_fb;
static int tls_mask;
 
210,93 → 224,7
return kgem_init_fb(&sna->kgem, &sna_fb);
}
 
int sna_init(uint32_t service)
{
ioctl_t io;
int caps = 0;
 
static struct pci_device device;
struct sna *sna;
 
DBG(("%s\n", __FUNCTION__));
 
__lock_acquire_recursive(__sna_lock);
 
if(sna_device)
goto done;
 
io.handle = service;
io.io_code = SRV_GET_PCI_INFO;
io.input = &device;
io.inp_size = sizeof(device);
io.output = NULL;
io.out_size = 0;
 
if (call_service(&io)!=0)
goto err1;
 
sna = malloc(sizeof(*sna));
if (sna == NULL)
goto err1;
 
memset(sna, 0, sizeof(*sna));
 
sna->cpu_features = sna_cpu_detect();
 
sna->PciInfo = &device;
sna->info = intel_detect_chipset(sna->PciInfo);
sna->scrn = service;
 
kgem_init(&sna->kgem, service, sna->PciInfo, sna->info->gen);
 
 
/* Disable tiling by default */
sna->tiling = 0;
 
/* Default fail-safe value of 75 Hz */
// sna->vblank_interval = 1000 * 1000 * 1000 / 75;
 
sna->flags = 0;
 
sna_accel_init(sna);
 
tls_mask = tls_alloc();
 
// printf("tls mask %x\n", tls_mask);
 
done:
caps = sna_device->render.caps;
 
err1:
__lock_release_recursive(__sna_lock);
 
return caps;
}
 
void sna_fini()
{
ENTER();
 
if( sna_device )
{
struct kgem_bo *mask;
 
__lock_acquire_recursive(__sna_lock);
 
mask = tls_get(tls_mask);
 
sna_device->render.fini(sna_device);
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);
};
LEAVE();
}
 
#if 0
 
static bool sna_solid_cache_init(struct sna *sna)
489,8 → 417,268
 
 
 
int sna_create_bitmap(bitmap_t *bitmap)
 
#define MI_LOAD_REGISTER_IMM (0x22<<23)
#define MI_WAIT_FOR_EVENT (0x03<<23)
 
static bool sna_emit_wait_for_scanline_gen6(struct sna *sna,
rect_t *crtc,
int pipe, int y1, int y2,
bool full_height)
{
uint32_t *b;
uint32_t event;
 
// if (!sna->kgem.has_secure_batches)
// return false;
 
assert(y1 >= 0);
assert(y2 > y1);
assert(sna->kgem.mode == KGEM_RENDER);
 
/* Always program one less than the desired value */
if (--y1 < 0)
y1 = crtc->b;
y2--;
 
/* The scanline granularity is 3 bits */
y1 &= ~7;
y2 &= ~7;
if (y2 == y1)
return false;
 
event = 1 << (3*full_height + pipe*8);
 
b = kgem_get_batch(&sna->kgem);
sna->kgem.nbatch += 10;
 
b[0] = MI_LOAD_REGISTER_IMM | 1;
b[1] = 0x44050; /* DERRMR */
b[2] = ~event;
b[3] = MI_LOAD_REGISTER_IMM | 1;
b[4] = 0x4f100; /* magic */
b[5] = (1 << 31) | (1 << 30) | pipe << 29 | (y1 << 16) | y2;
b[6] = MI_WAIT_FOR_EVENT | event;
b[7] = MI_LOAD_REGISTER_IMM | 1;
b[8] = 0x44050; /* DERRMR */
b[9] = ~0;
 
sna->kgem.batch_flags |= I915_EXEC_SECURE;
 
return true;
}
 
bool
sna_wait_for_scanline(struct sna *sna,
rect_t *crtc,
rect_t *clip)
{
bool full_height;
int y1, y2, pipe;
bool ret;
 
// if (sna->flags & SNA_NO_VSYNC)
// return false;
 
/*
* Make sure we don't wait for a scanline that will
* never occur
*/
y1 = clip->t - crtc->t;
if (y1 < 0)
y1 = 0;
y2 = clip->b - crtc->t;
if (y2 > crtc->b - crtc->t)
y2 = crtc->b - crtc->t;
// DBG(("%s: clipped range = %d, %d\n", __FUNCTION__, y1, y2));
// printf("%s: clipped range = %d, %d\n", __FUNCTION__, y1, y2);
 
if (y2 <= y1 + 4)
return false;
 
full_height = y1 == 0 && y2 == crtc->b - crtc->t;
 
pipe = 0;
DBG(("%s: pipe=%d, y1=%d, y2=%d, full_height?=%d\n",
__FUNCTION__, pipe, y1, y2, full_height));
 
if (sna->kgem.gen >= 0100)
ret = false;
// else if (sna->kgem.gen >= 075)
// ret = sna_emit_wait_for_scanline_hsw(sna, crtc, pipe, y1, y2, full_height);
// else if (sna->kgem.gen >= 070)
// ret = sna_emit_wait_for_scanline_ivb(sna, crtc, pipe, y1, y2, full_height);
else if (sna->kgem.gen >= 060)
ret =sna_emit_wait_for_scanline_gen6(sna, crtc, pipe, y1, y2, full_height);
// else if (sna->kgem.gen >= 040)
// ret = sna_emit_wait_for_scanline_gen4(sna, crtc, pipe, y1, y2, full_height);
 
return ret;
}
 
 
 
 
 
 
 
 
 
static const struct intel_device_info intel_generic_info = {
.gen = -1,
};
 
static const struct intel_device_info intel_i915_info = {
.gen = 030,
};
static const struct intel_device_info intel_i945_info = {
.gen = 031,
};
 
static const struct intel_device_info intel_g33_info = {
.gen = 033,
};
 
static const struct intel_device_info intel_i965_info = {
.gen = 040,
};
 
static const struct intel_device_info intel_g4x_info = {
.gen = 045,
};
 
static const struct intel_device_info intel_ironlake_info = {
.gen = 050,
};
 
static const struct intel_device_info intel_sandybridge_info = {
.gen = 060,
};
 
static const struct intel_device_info intel_ivybridge_info = {
.gen = 070,
};
 
static const struct intel_device_info intel_valleyview_info = {
.gen = 071,
};
 
static const struct intel_device_info intel_haswell_info = {
.gen = 075,
};
 
#define INTEL_DEVICE_MATCH(d,i) \
{ 0x8086, (d), PCI_MATCH_ANY, PCI_MATCH_ANY, 0x3 << 16, 0xff << 16, (intptr_t)(i) }
 
 
static const struct pci_id_match intel_device_match[] = {
 
INTEL_I915G_IDS(&intel_i915_info),
INTEL_I915GM_IDS(&intel_i915_info),
INTEL_I945G_IDS(&intel_i945_info),
INTEL_I945GM_IDS(&intel_i945_info),
 
INTEL_G33_IDS(&intel_g33_info),
INTEL_PINEVIEW_IDS(&intel_g33_info),
 
INTEL_I965G_IDS(&intel_i965_info),
INTEL_I965GM_IDS(&intel_i965_info),
 
INTEL_G45_IDS(&intel_g4x_info),
INTEL_GM45_IDS(&intel_g4x_info),
 
INTEL_IRONLAKE_D_IDS(&intel_ironlake_info),
INTEL_IRONLAKE_M_IDS(&intel_ironlake_info),
 
INTEL_SNB_D_IDS(&intel_sandybridge_info),
INTEL_SNB_M_IDS(&intel_sandybridge_info),
 
INTEL_IVB_D_IDS(&intel_ivybridge_info),
INTEL_IVB_M_IDS(&intel_ivybridge_info),
 
INTEL_HSW_D_IDS(&intel_haswell_info),
INTEL_HSW_M_IDS(&intel_haswell_info),
 
INTEL_VLV_D_IDS(&intel_valleyview_info),
INTEL_VLV_M_IDS(&intel_valleyview_info),
 
INTEL_VGA_DEVICE(PCI_MATCH_ANY, &intel_generic_info),
 
{ 0, 0, 0 },
};
 
const struct pci_id_match *PciDevMatch(uint16_t dev,const struct pci_id_match *list)
{
while(list->device_id)
{
if(dev==list->device_id)
return list;
list++;
}
return NULL;
}
 
const struct intel_device_info *
intel_detect_chipset(struct pci_device *pci)
{
const struct pci_id_match *ent = NULL;
 
ent = PciDevMatch(pci->device_id, intel_device_match);
 
if(ent != NULL)
return (const struct intel_device_info*)ent->match_data;
else
return &intel_generic_info;
}
 
int intel_get_device_id(int fd)
{
struct drm_i915_getparam gp;
int devid = 0;
 
memset(&gp, 0, sizeof(gp));
gp.param = I915_PARAM_CHIPSET_ID;
gp.value = &devid;
 
if (drmIoctl(fd, DRM_IOCTL_I915_GETPARAM, &gp))
return 0;
 
return devid;
}
 
int drmIoctl(int fd, unsigned long request, void *arg)
{
ioctl_t io;
 
io.handle = fd;
io.io_code = request;
io.input = arg;
io.inp_size = 64;
io.output = NULL;
io.out_size = 0;
 
return call_service(&io);
}
 
 
 
bool
gen6_composite(struct sna *sna,
uint8_t op,
PixmapPtr src, struct kgem_bo *src_bo,
PixmapPtr mask,struct kgem_bo *mask_bo,
PixmapPtr dst, struct kgem_bo *dst_bo,
int32_t src_x, int32_t src_y,
int32_t msk_x, int32_t msk_y,
int32_t dst_x, int32_t dst_y,
int32_t width, int32_t height,
struct sna_composite_op *tmp);
 
//#define MAP(ptr) ((void*)((uintptr_t)(ptr) & ~3))
 
 
int sna_bitmap_from_handle(bitmap_t *bitmap, uint32_t handle)
{
surface_t *sf;
struct kgem_bo *bo;
 
500,19 → 688,13
 
__lock_acquire_recursive(__sna_lock);
 
bo = kgem_create_2d(&sna_device->kgem, bitmap->width, bitmap->height,
32,I915_TILING_NONE, CREATE_CPU_MAP);
bo = kgem_bo_from_handle(&sna_device->kgem, handle, bitmap->pitch, bitmap->height);
 
if(bo == NULL)
goto err_2;
__lock_release_recursive(__sna_lock);
 
void *map = kgem_bo_map(&sna_device->kgem, bo);
if(map == NULL)
goto err_3;
 
sf->width = bitmap->width;
sf->height = bitmap->height;
sf->data = map;
sf->data = NULL;
sf->pitch = bo->pitch;
sf->bo = bo;
sf->bo_size = PAGE_SIZE * bo->size.pages.count;
519,12 → 701,9
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:
__lock_release_recursive(__sna_lock);
free(sf);
532,8 → 711,15
return -1;
};
 
int sna_bitmap_from_handle(bitmap_t *bitmap, uint32_t handle)
void sna_set_bo_handle(bitmap_t *bitmap, int handle)
{
surface_t *sf = to_surface(bitmap);
struct kgem_bo *bo = sf->bo;
bo->handle = handle;
}
 
static int sna_create_bitmap(bitmap_t *bitmap)
{
surface_t *sf;
struct kgem_bo *bo;
 
543,13 → 729,19
 
__lock_acquire_recursive(__sna_lock);
 
bo = kgem_bo_from_handle(&sna_device->kgem, handle, bitmap->pitch, bitmap->height);
bo = kgem_create_2d(&sna_device->kgem, bitmap->width, bitmap->height,
32,I915_TILING_NONE, CREATE_CPU_MAP);
 
__lock_release_recursive(__sna_lock);
if(bo == NULL)
goto err_2;
 
void *map = kgem_bo_map(&sna_device->kgem, bo);
if(map == NULL)
goto err_3;
 
sf->width = bitmap->width;
sf->height = bitmap->height;
sf->data = NULL;
sf->data = map;
sf->pitch = bo->pitch;
sf->bo = bo;
sf->bo_size = PAGE_SIZE * bo->size.pages.count;
556,9 → 748,12
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:
__lock_release_recursive(__sna_lock);
free(sf);
566,17 → 761,10
return -1;
};
 
void sna_set_bo_handle(bitmap_t *bitmap, int handle)
static int sna_destroy_bitmap(bitmap_t *bitmap)
{
surface_t *sf = to_surface(bitmap);
struct kgem_bo *bo = sf->bo;
bo->handle = handle;
}
 
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);
592,7 → 780,7
return 0;
};
 
int sna_lock_bitmap(bitmap_t *bitmap)
static int sna_lock_bitmap(bitmap_t *bitmap)
{
surface_t *sf = to_surface(bitmap);
 
609,7 → 797,7
return 0;
};
 
int sna_resize_bitmap(bitmap_t *bitmap)
static int sna_resize_bitmap(bitmap_t *bitmap)
{
surface_t *sf = to_surface(bitmap);
struct kgem *kgem = &sna_device->kgem;
707,120 → 895,8
return -1;
};
 
#define MI_LOAD_REGISTER_IMM (0x22<<23)
#define MI_WAIT_FOR_EVENT (0x03<<23)
 
static bool sna_emit_wait_for_scanline_gen6(struct sna *sna,
rect_t *crtc,
int pipe, int y1, int y2,
bool full_height)
{
uint32_t *b;
uint32_t event;
 
// if (!sna->kgem.has_secure_batches)
// return false;
 
assert(y1 >= 0);
assert(y2 > y1);
assert(sna->kgem.mode == KGEM_RENDER);
 
/* Always program one less than the desired value */
if (--y1 < 0)
y1 = crtc->b;
y2--;
 
/* The scanline granularity is 3 bits */
y1 &= ~7;
y2 &= ~7;
if (y2 == y1)
return false;
 
event = 1 << (3*full_height + pipe*8);
 
b = kgem_get_batch(&sna->kgem);
sna->kgem.nbatch += 10;
 
b[0] = MI_LOAD_REGISTER_IMM | 1;
b[1] = 0x44050; /* DERRMR */
b[2] = ~event;
b[3] = MI_LOAD_REGISTER_IMM | 1;
b[4] = 0x4f100; /* magic */
b[5] = (1 << 31) | (1 << 30) | pipe << 29 | (y1 << 16) | y2;
b[6] = MI_WAIT_FOR_EVENT | event;
b[7] = MI_LOAD_REGISTER_IMM | 1;
b[8] = 0x44050; /* DERRMR */
b[9] = ~0;
 
sna->kgem.batch_flags |= I915_EXEC_SECURE;
 
return true;
}
 
bool
sna_wait_for_scanline(struct sna *sna,
rect_t *crtc,
rect_t *clip)
{
bool full_height;
int y1, y2, pipe;
bool ret;
 
// if (sna->flags & SNA_NO_VSYNC)
// return false;
 
/*
* Make sure we don't wait for a scanline that will
* never occur
*/
y1 = clip->t - crtc->t;
if (y1 < 0)
y1 = 0;
y2 = clip->b - crtc->t;
if (y2 > crtc->b - crtc->t)
y2 = crtc->b - crtc->t;
// DBG(("%s: clipped range = %d, %d\n", __FUNCTION__, y1, y2));
// printf("%s: clipped range = %d, %d\n", __FUNCTION__, y1, y2);
 
if (y2 <= y1 + 4)
return false;
 
full_height = y1 == 0 && y2 == crtc->b - crtc->t;
 
pipe = 0;
DBG(("%s: pipe=%d, y1=%d, y2=%d, full_height?=%d\n",
__FUNCTION__, pipe, y1, y2, full_height));
 
if (sna->kgem.gen >= 0100)
ret = false;
// else if (sna->kgem.gen >= 075)
// ret = sna_emit_wait_for_scanline_hsw(sna, crtc, pipe, y1, y2, full_height);
// else if (sna->kgem.gen >= 070)
// ret = sna_emit_wait_for_scanline_ivb(sna, crtc, pipe, y1, y2, full_height);
else if (sna->kgem.gen >= 060)
ret =sna_emit_wait_for_scanline_gen6(sna, crtc, pipe, y1, y2, full_height);
// else if (sna->kgem.gen >= 040)
// ret = sna_emit_wait_for_scanline_gen4(sna, crtc, pipe, y1, y2, full_height);
 
return ret;
}
 
 
bool
gen6_composite(struct sna *sna,
uint8_t op,
PixmapPtr src, struct kgem_bo *src_bo,
PixmapPtr mask,struct kgem_bo *mask_bo,
PixmapPtr dst, struct kgem_bo *dst_bo,
int32_t src_x, int32_t src_y,
int32_t msk_x, int32_t msk_y,
int32_t dst_x, int32_t dst_y,
int32_t width, int32_t height,
struct sna_composite_op *tmp);
 
 
#define MAP(ptr) ((void*)((uintptr_t)(ptr) & ~3))
 
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)
 
948,146 → 1024,97
}
 
 
static void sna_fini()
{
ENTER();
 
if( sna_device )
{
struct kgem_bo *mask;
 
__lock_acquire_recursive(__sna_lock);
 
mask = tls_get(tls_mask);
 
sna_device->render.fini(sna_device);
if(mask)
kgem_bo_destroy(&sna_device->kgem, mask);
// kgem_close_batches(&sna_device->kgem);
kgem_cleanup_cache(&sna_device->kgem);
 
static const struct intel_device_info intel_generic_info = {
.gen = -1,
sna_device = NULL;
__lock_release_recursive(__sna_lock);
};
LEAVE();
}
 
static const struct intel_device_info intel_i915_info = {
.gen = 030,
};
static const struct intel_device_info intel_i945_info = {
.gen = 031,
};
uint32_t DrvInit(uint32_t service, struct pix_driver *driver)
{
ioctl_t io;
int caps = 0;
 
static const struct intel_device_info intel_g33_info = {
.gen = 033,
};
static struct pci_device device;
struct sna *sna;
 
static const struct intel_device_info intel_i965_info = {
.gen = 040,
};
DBG(("%s\n", __FUNCTION__));
 
static const struct intel_device_info intel_g4x_info = {
.gen = 045,
};
__lock_acquire_recursive(__sna_lock);
 
static const struct intel_device_info intel_ironlake_info = {
.gen = 050,
};
if(sna_device)
goto done;
 
static const struct intel_device_info intel_sandybridge_info = {
.gen = 060,
};
io.handle = service;
io.io_code = SRV_GET_PCI_INFO;
io.input = &device;
io.inp_size = sizeof(device);
io.output = NULL;
io.out_size = 0;
 
static const struct intel_device_info intel_ivybridge_info = {
.gen = 070,
};
if (call_service(&io)!=0)
goto err1;
 
static const struct intel_device_info intel_valleyview_info = {
.gen = 071,
};
sna = malloc(sizeof(*sna));
if (sna == NULL)
goto err1;
 
static const struct intel_device_info intel_haswell_info = {
.gen = 075,
};
memset(sna, 0, sizeof(*sna));
 
#define INTEL_DEVICE_MATCH(d,i) \
{ 0x8086, (d), PCI_MATCH_ANY, PCI_MATCH_ANY, 0x3 << 16, 0xff << 16, (intptr_t)(i) }
sna->cpu_features = sna_cpu_detect();
 
sna->PciInfo = &device;
sna->info = intel_detect_chipset(sna->PciInfo);
sna->scrn = service;
 
static const struct pci_id_match intel_device_match[] = {
kgem_init(&sna->kgem, service, sna->PciInfo, sna->info->gen);
 
INTEL_I915G_IDS(&intel_i915_info),
INTEL_I915GM_IDS(&intel_i915_info),
INTEL_I945G_IDS(&intel_i945_info),
INTEL_I945GM_IDS(&intel_i945_info),
/* Disable tiling by default */
sna->tiling = 0;
 
INTEL_G33_IDS(&intel_g33_info),
INTEL_PINEVIEW_IDS(&intel_g33_info),
/* Default fail-safe value of 75 Hz */
// sna->vblank_interval = 1000 * 1000 * 1000 / 75;
 
INTEL_I965G_IDS(&intel_i965_info),
INTEL_I965GM_IDS(&intel_i965_info),
sna->flags = 0;
 
INTEL_G45_IDS(&intel_g4x_info),
INTEL_GM45_IDS(&intel_g4x_info),
sna_accel_init(sna);
 
INTEL_IRONLAKE_D_IDS(&intel_ironlake_info),
INTEL_IRONLAKE_M_IDS(&intel_ironlake_info),
tls_mask = tls_alloc();
 
INTEL_SNB_D_IDS(&intel_sandybridge_info),
INTEL_SNB_M_IDS(&intel_sandybridge_info),
// printf("tls mask %x\n", tls_mask);
 
INTEL_IVB_D_IDS(&intel_ivybridge_info),
INTEL_IVB_M_IDS(&intel_ivybridge_info),
driver->create_bitmap = sna_create_bitmap;
driver->destroy_bitmap = sna_destroy_bitmap;
driver->lock_bitmap = sna_lock_bitmap;
driver->blit = sna_blit_tex;
driver->resize_bitmap = sna_resize_bitmap;
driver->fini = sna_fini;
done:
caps = sna_device->render.caps;
 
INTEL_HSW_D_IDS(&intel_haswell_info),
INTEL_HSW_M_IDS(&intel_haswell_info),
err1:
__lock_release_recursive(__sna_lock);
 
INTEL_VLV_D_IDS(&intel_valleyview_info),
INTEL_VLV_M_IDS(&intel_valleyview_info),
 
INTEL_VGA_DEVICE(PCI_MATCH_ANY, &intel_generic_info),
 
{ 0, 0, 0 },
};
 
const struct pci_id_match *PciDevMatch(uint16_t dev,const struct pci_id_match *list)
{
while(list->device_id)
{
if(dev==list->device_id)
return list;
list++;
return caps;
}
return NULL;
}
 
const struct intel_device_info *
intel_detect_chipset(struct pci_device *pci)
{
const struct pci_id_match *ent = NULL;
 
ent = PciDevMatch(pci->device_id, intel_device_match);
 
if(ent != NULL)
return (const struct intel_device_info*)ent->match_data;
else
return &intel_generic_info;
}
 
int intel_get_device_id(int fd)
{
struct drm_i915_getparam gp;
int devid = 0;
 
memset(&gp, 0, sizeof(gp));
gp.param = I915_PARAM_CHIPSET_ID;
gp.value = &devid;
 
if (drmIoctl(fd, DRM_IOCTL_I915_GETPARAM, &gp))
return 0;
 
return devid;
}
 
int drmIoctl(int fd, unsigned long request, void *arg)
{
ioctl_t io;
 
io.handle = fd;
io.io_code = request;
io.input = arg;
io.inp_size = 64;
io.output = NULL;
io.out_size = 0;
 
return call_service(&io);
}
 
 
 
/contrib/sdk/sources/Intel-2D/sna.ver
0,0 → 1,15
LIBDRM {
global: DllStartup;
DrvInit;
sna_bitmap_from_handle;
sna_blit_tex;
sna_create_mask;
sna_set_bo_handle;
 
local: __chkstk;
__chkstk_ms;
_alloca;
__uxa_lock;
_nm__tls_alloc;
*;
};