WebSVN – Kolibri OS – Diff – /drivers/video/Intel-2D/sna.c

-//#include "../bitmap.h"
+#include
 #include
 #include
+#include
-#include
+#include "sna.h"
-#include "sna.h"
+#define to_surface(x) (surface_t*)((x)->handle)
-#include
+static struct sna_fb sna_fb;
+static int    tls_mask;
 static struct sna_fb sna_fb;
-static struct kgem_bo *mask_bo;
-static int mask_width, mask_height;
+int tls_alloc(void);
-typedef struct __attribute__((packed))
-{
-  unsigned      handle;
-  unsigned      io_code;
-  void          *input;
-  int           inp_size;
-  void          *output;
-  int           out_size;
-}ioctl_t;
+static inline void *tls_get(int key)
+{
-static int call_service(ioctl_t *io)
-{
+    void *val;
-  int retval;
+    __asm__ __volatile__(
     "movl %%fs:(%1), %0"
+    :"=r"(val)
-  asm volatile("int $0x40"
+    :"r"(key));
+  return val;
-      :"=a"(retval)
+};
       :"a"(68),"b"(17),"c"(io)
+static inline int
+tls_set(int key, const void *ptr)
-      :"memory","cc");
+{
+    if(!(key & 3))
-  return retval;
+    {
-};
+        __asm__ __volatile__(
+        "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,
-static inline void get_proc_info(char *info)
+				  unsigned flags, uint32_t width, uint32_t height,
 				  uint32_t bpp, uint32_t tiling, uint32_t *pitch);
     __asm__ __volatile__(
-    "int $0x40"
+void kgem_close_batches(struct kgem *kgem);
+void sna_bo_destroy(struct kgem *kgem, struct kgem_bo *bo);
 const struct intel_device_info *
-    :"a"(9), "b"(info), "c"(-1));
+intel_detect_chipset(struct pci_device *pci);
 //struct kgem_bo *create_bo(bitmap_t *bitmap);
 int sna_init(uint32_t service)
+{
-int sna_init(uint32_t service)
+    ioctl_t   io;
     int caps = 0;
-    ioctl_t   io;
+    static struct pci_device device;
     struct sna *sna;
     static struct pci_device device;
-    struct sna *sna;
+    DBG(("%s\n", __FUNCTION__));
-    DBG(("%s\n", __FUNCTION__));
+    __lock_acquire_recursive(__sna_lock);
     sna = malloc(sizeof(*sna));
-    if (sna == NULL)
+    if(sna_device)
-        return 0;
+        goto done;
-    memset(sna, 0, sizeof(*sna));
+    io.handle   = service;
     io.io_code  = SRV_GET_PCI_INFO;
-    io.handle   = service;
+    io.input    = &device;
-    io.io_code  = SRV_GET_PCI_INFO;
+    io.inp_size = sizeof(device);
+    io.output   = NULL;
-    io.input    = &device;
+    io.out_size = 0;
-    io.inp_size = sizeof(device);
+    if (call_service(&io)!=0)
-    io.output   = NULL;
+        goto err1;
-    io.out_size = 0;
+    sna = malloc(sizeof(*sna));
     if (sna == NULL)
-    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:
-    sna_accel_init(sna);
+    __lock_release_recursive(__sna_lock);
-    delay(10);
+    return caps;
+}
     return sna->render.caps;
 void sna_fini()
+{
+    if( sna_device )
+    {
+        struct kgem_bo *mask;
+        __lock_acquire_recursive(__sna_lock);
+        mask = tls_get(tls_mask);
-void sna_fini()
         sna_device->render.fini(sna_device);
-    if( 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->render.fini(sna_device);
+   	    sna_device = NULL;
-        kgem_bo_destroy(&sna_device->kgem, mask_bo);
+        __lock_release_recursive(__sna_lock);
-done:
+    return kgem_bo_reference(cache->bo[i]);
     cache->last = i;
     return kgem_bo_reference(cache->bo[i]);
 #endif
 int sna_blit_copy(bitmap_t *src_bitmap, int dst_x, int dst_y,
         copy.done(sna_device, ©);
     kgem_submit(&sna_device->kgem);
+    return 0;
-    kgem_submit(&sna_device->kgem);
+//    __asm__ __volatile__("int3");
+};
-//    __asm__ __volatile__("int3");
+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;
 };
-#endif
+int sna_create_bitmap(bitmap_t *bitmap)
+{
+    surface_t *sf;
+	struct kgem_bo *bo;
+    sf = malloc(sizeof(*sf));
+    if(sf == NULL)
         goto err_1;
-int sna_create_bitmap(bitmap_t *bitmap)
+    __lock_acquire_recursive(__sna_lock);
-{
-	struct kgem_bo *bo;
+    bo = kgem_create_2d(&sna_device->kgem, bitmap->width, bitmap->height,
 ,I915_TILING_NONE, CREATE_CPU_MAP);
-    bo = kgem_create_2d(&sna_device->kgem, bitmap->width, bitmap->height,
+    if(bo == NULL)
-,I915_TILING_NONE, CREATE_CPU_MAP);
+        goto err_2;
+    void *map = kgem_bo_map(&sna_device->kgem, bo);
+    if(map == NULL)
+        goto err_3;
+    sf->width   = bitmap->width;
-    if(bo == NULL)
+    sf->height  = bitmap->height;
+    sf->data    = map;
-        goto err_1;
+    sf->pitch   = bo->pitch;
+    sf->bo      = bo;
-    void *map = kgem_bo_map(&sna_device->kgem, bo);
+    sf->bo_size = PAGE_SIZE * bo->size.pages.count;
-    if(map == NULL)
+    sf->flags   = bitmap->flags;
+    bitmap->handle = (uint32_t)sf;
-        goto err_2;
+    __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);
+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);
     bitmap->handle = (uint32_t)bo;
-    bitmap->pitch  = bo->pitch;
+    __lock_release_recursive(__sna_lock);
     bitmap->data   = map;
+    free(sf);
-    return 0;
+    bitmap->handle = -1;
+    bitmap->data   = (void*)-1;
+    bitmap->pitch  = -1;
+    return 0;
+};
+int sna_lock_bitmap(bitmap_t *bitmap)
 err_2:
-    kgem_bo_destroy(&sna_device->kgem, bo);
+    surface_t *sf = to_surface(bitmap);
+//    printf("%s\n", __FUNCTION__);
+    __lock_acquire_recursive(__sna_lock);
-err_1:
+    kgem_bo_sync__cpu(&sna_device->kgem, sf->bo);
-    return -1;
+    __lock_release_recursive(__sna_lock);
+    bitmap->data  = sf->data;
+    bitmap->pitch = sf->pitch;
+    return 0;
+};
+int sna_resize_bitmap(bitmap_t *bitmap)
+{
+    surface_t *sf = to_surface(bitmap);
+    struct kgem *kgem = &sna_device->kgem;
+    struct kgem_bo *bo = sf->bo;
+    uint32_t   size;
+    uint32_t   pitch;
+   	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,
+, 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);
-void sna_destroy_bitmap(bitmap_t *bitmap)
+            return -1;
         };
-	struct kgem_bo *bo;
     bo = (struct kgem_bo *)bitmap->handle;
+        __lock_release_recursive(__sna_lock);
         sf->width   = bitmap->width;
-    kgem_bo_destroy(&sna_device->kgem, bo);
+        sf->height  = bitmap->height;
+        sf->data    = map;
-};
+        sf->pitch   = bo->pitch;
         sf->bo      = bo;
-void sna_lock_bitmap(bitmap_t *bitmap)
+        sf->bo_size = PAGE_SIZE * bo->size.pages.count;
+    }
-	struct kgem_bo *bo;
-    bo = (struct kgem_bo *)bitmap->handle;
+    return 0;
+};
     kgem_bo_sync__cpu(&sna_device->kgem, bo);
-};
+int sna_create_mask()
 int sna_create_mask()
+	struct kgem_bo *bo;
-	struct kgem_bo *bo;
-    int width, height;
+//    printf("%s width %d height %d\n", __FUNCTION__, sna_fb.width, sna_fb.height);
     int i;
     __lock_acquire_recursive(__sna_lock);
               struct sna_composite_op *tmp);
 #define MAP(ptr) ((void*)((uintptr_t)(ptr) & ~3))
-#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)
-int sna_blit_tex(bitmap_t *src_bitmap, int dst_x, int dst_y,
-                  int w, int h, int src_x, int src_y)
-{
-//    box.x1 = dst_x;
-//    box.y1 = dst_y;
-//    box.x2 = dst_x+w;
 //    box.y2 = dst_y+h;
     surface_t *sf = to_surface(bitmap);
- //   cop.box(sna_device, &cop, &box);
+    struct drm_i915_mask_update update;
     struct sna_composite_op composite;
-    struct drm_i915_mask_update update;
     struct _Pixmap src, dst, mask;
-    struct sna_composite_op composite;
+    struct kgem_bo *src_bo, *mask_bo;
-    struct _Pixmap src, dst, mask;
+    int winx, winy;
-    struct kgem_bo *src_bo;
+    char proc_info[1024];
+    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;
+    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);
-    char proc_info[1024];
+        __lock_release_recursive(__sna_lock);
     int winx, winy, winw, winh;
-    get_proc_info(proc_info);
         sna_create_mask();
-    winx = *(uint32_t*)(proc_info+34);
+        mask_bo = tls_get(tls_mask);
-    winy = *(uint32_t*)(proc_info+38);
+        if( mask_bo == NULL)
-    winw = *(uint32_t*)(proc_info+42)+1;
+            return -1;
     winh = *(uint32_t*)(proc_info+46)+1;
     VG_CLEAR(update);
+	update.handle = mask_bo->handle;
-	update.handle = mask_bo->handle;
+	update.bo_map    = (__u32)MAP(mask_bo->map);
-//	update.bo_size   = __kgem_bo_size(mask_bo);
+	drmIoctl(sna_device->kgem.fd, SRV_MASK_UPDATE, &update);
-//	update.bo_pitch  = mask_bo->pitch;
+    mask_bo->pitch = update.bo_pitch;
 	update.bo_map    = (__u32)MAP(mask_bo->map);
-	drmIoctl(sna_device->kgem.fd, SRV_MASK_UPDATE, &update);
+    memset(&src, 0, sizeof(src));
     mask.drawable.width  = update.width;
-    mask.drawable.height = update.height;
+    memset(&composite, 0, sizeof(composite));
+    src_bo = sf->bo;
-    memset(&composite, 0, sizeof(composite));
+    __lock_acquire_recursive(__sna_lock);
     src_bo = (struct kgem_bo*)src_bitmap->handle;
     if( sna_device->render.blit_tex(sna_device, PictOpSrc,scale,
 		      &src, src_bo,
-    if( sna_device->render.blit_tex(sna_device, PictOpSrc,
+		      &mask, mask_bo,
-		      &src, src_bo,
+		      &dst, sna_fb.fb_bo,
 	    r.width  = w;
-	    r.height = h;
+        composite.blt(sna_device, &composite, &r);
         composite.done(sna_device, &composite);
         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;
-    kgem_submit(&sna_device->kgem);
+    return 0;
 intel_detect_chipset(struct pci_device *pci)
 const struct intel_device_info *
-intel_detect_chipset(struct pci_device *pci)
+    const struct pci_id_match *ent = NULL;
-    const struct pci_id_match *ent = NULL;
-	const char *name = NULL;
-	int i;
+    ent = PciDevMatch(pci->device_id, intel_device_match);
-    ent = PciDevMatch(pci->device_id, intel_device_match);
+    if(ent != NULL)

Subversion Repositories Kolibri OS

(root)/drivers/video/Intel-2D/sna.c – Rev 3299 → 3769