Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 6283 → Rev 6282

/drivers/video/drm/i915/kos_cursor.c
File deleted
/drivers/video/drm/i915/Makefile
111,7 → 111,6
intel_sprite.c \
intel_uncore.c \
kms_display.c \
kos_cursor.c \
utils.c \
fwblob.asm \
../hdmi.c \
/drivers/video/drm/i915/i915_gem.c
2786,6 → 2786,11
struct drm_i915_gem_object *obj = vma->obj;
struct drm_i915_private *dev_priv = obj->base.dev->dev_private;
int ret;
if(obj == get_fb_obj())
{
WARN(1,"attempt to unbind fb object\n");
return 0;
};
 
if (list_empty(&vma->vma_link))
return 0;
3950,25 → 3955,6
return obj;
}
 
static bool discard_backing_storage(struct drm_i915_gem_object *obj)
{
/* If we are the last user of the backing storage (be it shmemfs
* pages or stolen etc), we know that the pages are going to be
* immediately released. In this case, we can then skip copying
* back the contents from the GPU.
*/
 
if (obj->madv != I915_MADV_WILLNEED)
return false;
 
if (obj->base.filp == NULL)
return true;
 
// printf("filp %p\n", obj->base.filp);
shmem_file_delete(obj->base.filp);
return true;
}
 
void i915_gem_free_object(struct drm_gem_object *gem_obj)
{
struct drm_i915_gem_object *obj = to_intel_bo(gem_obj);
4011,16 → 3997,18
 
if (WARN_ON(obj->pages_pin_count))
obj->pages_pin_count = 0;
if (discard_backing_storage(obj))
obj->madv = I915_MADV_DONTNEED;
i915_gem_object_put_pages(obj);
// i915_gem_object_free_mmap_offset(obj);
 
BUG_ON(obj->pages);
 
if (obj->ops->release)
obj->ops->release(obj);
 
if(obj->base.filp != NULL)
{
// printf("filp %p\n", obj->base.filp);
shmem_file_delete(obj->base.filp);
}
 
drm_gem_object_release(&obj->base);
i915_gem_info_remove_obj(dev_priv, obj->base.size);
 
/drivers/video/drm/i915/i915_gem_stolen.c
415,6 → 415,16
*/
drm_mm_init(&dev_priv->mm.stolen, 0, dev_priv->gtt.stolen_usable_size);
 
{
u32 usable_size = dev_priv->gtt.stolen_usable_size >> 20;
if(i915.fbsize > usable_size)
{
i915.fbsize = usable_size;
DRM_DEBUG_KMS("Adjust framebuffer size to match reserved memory\n"
"new fbsize %dMB\n",i915.fbsize);
}
}
 
return 0;
}
 
/drivers/video/drm/i915/i915_params.c
40,7 → 40,7
.preliminary_hw_support = IS_ENABLED(CONFIG_DRM_I915_PRELIMINARY_HW_SUPPORT),
.disable_power_well = -1,
.enable_ips = 1,
.fastboot = 0,
.fastboot = 1,
.prefault_disable = 0,
.load_detect_test = 0,
.reset = true,
/drivers/video/drm/i915/kms_display.c
11,16 → 11,13
 
#include <syscall.h>
 
//#include "bitmap.h"
#include "bitmap.h"
#include <display.h>
 
void FASTCALL sysSetFramebuffer(void *fb)__asm__("SetFramebuffer");
void kolibri_framebuffer_update(struct drm_i915_private *dev_priv, struct kos_framebuffer *kfb);
void init_system_cursors(struct drm_device *dev);
 
addr_t dummy_fb_page;
 
display_t *os_display;
struct drm_i915_gem_object *main_fb_obj;
struct drm_framebuffer *main_framebuffer;
 
u32 cmd_buffer;
u32 cmd_offset;
28,6 → 25,17
void init_render();
int sna_init();
 
static cursor_t* __stdcall select_cursor_kms(cursor_t *cursor);
static void __stdcall move_cursor_kms(cursor_t *cursor, int x, int y);
 
void __stdcall restore_cursor(int x, int y)
{};
 
void disable_mouse(void)
{};
 
struct mutex cursor_lock;
 
static char *manufacturer_name(unsigned char *x)
{
static char name[4];
51,135 → 59,19
return count;
};
 
struct drm_framebuffer *get_framebuffer(struct drm_device *dev, struct drm_display_mode *mode, int tiling)
{
struct drm_i915_private *dev_priv = dev->dev_private;
struct intel_fbdev *ifbdev = dev_priv->fbdev;
struct intel_framebuffer *intel_fb = ifbdev->fb;
struct drm_framebuffer *fb = &intel_fb->base;
struct drm_i915_gem_object *obj = NULL;
int stride, size;
 
ENTER();
 
stride = mode->hdisplay *4;
 
if(tiling)
{
int gen3size;
 
if(IS_GEN3(dev))
for (stride = 512; stride < mode->hdisplay * 4; stride <<= 1);
else
stride = ALIGN(stride, 512);
size = stride * ALIGN(mode->vdisplay, 8);
 
if(IS_GEN3(dev))
{
for (gen3size = 1024*1024; gen3size < size; gen3size <<= 1);
size = gen3size;
}
else
size = ALIGN(size, 4096);
}
else
{
stride = ALIGN(stride, 64);
size = stride * ALIGN(mode->vdisplay, 2);
}
 
dbgprintf("size %x stride %x\n", size, stride);
 
if(intel_fb == NULL || size > intel_fb->obj->base.size)
{
struct drm_mode_fb_cmd2 mode_cmd = {};
int ret;
 
DRM_DEBUG_KMS("remove old framebuffer\n");
drm_framebuffer_remove(fb);
ifbdev->fb = NULL;
fb = NULL;
DRM_DEBUG_KMS("create new framebuffer\n");
 
mode_cmd.width = mode->hdisplay;
mode_cmd.height = mode->vdisplay;
 
mode_cmd.pitches[0] = stride;
mode_cmd.pixel_format = DRM_FORMAT_XRGB8888;
 
mutex_lock(&dev->struct_mutex);
 
/* If the FB is too big, just don't use it since fbdev is not very
* important and we should probably use that space with FBC or other
* features. */
if (size * 2 < dev_priv->gtt.stolen_usable_size)
obj = i915_gem_object_create_stolen(dev, size);
if (obj == NULL)
obj = i915_gem_alloc_object(dev, size);
if (!obj) {
DRM_ERROR("failed to allocate framebuffer\n");
ret = -ENOMEM;
goto out;
}
 
fb = __intel_framebuffer_create(dev, &mode_cmd, obj);
if (IS_ERR(fb)) {
ret = PTR_ERR(fb);
goto out_unref;
}
 
/* Flush everything out, we'll be doing GTT only from now on */
ret = intel_pin_and_fence_fb_obj(NULL, fb, NULL, NULL, NULL);
if (ret) {
DRM_ERROR("failed to pin obj: %d\n", ret);
goto out_fb;
}
mutex_unlock(&dev->struct_mutex);
ifbdev->fb = to_intel_framebuffer(fb);
}
 
obj = ifbdev->fb->obj;
 
if(tiling)
{
obj->tiling_mode = I915_TILING_X;
fb->modifier[0] = I915_FORMAT_MOD_X_TILED;
obj->fence_dirty = true;
obj->stride = stride;
};
 
fb->width = mode->hdisplay;
fb->height = mode->vdisplay;
 
fb->pitches[0] =
fb->pitches[1] =
fb->pitches[2] =
fb->pitches[3] = stride;
 
fb->bits_per_pixel = 32;
fb->depth = 24;
LEAVE();
return fb;
 
out_fb:
drm_framebuffer_remove(fb);
out_unref:
drm_gem_object_unreference(&obj->base);
out:
mutex_unlock(&dev->struct_mutex);
return NULL;
}
 
static int set_mode(struct drm_device *dev, struct drm_connector *connector,
struct drm_crtc *crtc, videomode_t *reqmode, bool strict)
{
struct drm_i915_private *dev_priv = dev->dev_private;
 
struct drm_mode_config *config = &dev->mode_config;
struct drm_display_mode *mode = NULL, *tmpmode;
struct drm_connector *tmpc;
struct drm_framebuffer *fb = NULL;
struct drm_mode_set set;
char con_edid[128];
const char *con_name;
unsigned hdisplay, vdisplay;
int stride;
int ret;
 
drm_modeset_lock_all(dev);
216,42 → 108,73
};
};
 
out:
drm_modeset_unlock_all(dev);
DRM_ERROR("%s failed\n", __FUNCTION__);
 
return -1;
 
do_set:
 
drm_modeset_unlock_all(dev);
 
fb = get_framebuffer(dev, mode, 1);
if(fb == NULL)
{
DRM_ERROR("%s failed\n", __FUNCTION__);
return -1;
};
drm_framebuffer_reference(fb);
con_name = connector->name;
 
drm_modeset_lock_all(dev);
char con_edid[128];
 
memcpy(con_edid, connector->edid_blob_ptr->data, 128);
 
DRM_DEBUG_KMS("set mode %dx%d: crtc %d connector %s\n"
"monitor: %s model %x serial number %u\n",
mode->hdisplay, mode->vdisplay,
crtc->base.id, connector->name,
DRM_DEBUG_KMS("Manufacturer: %s Model %x Serial Number %u\n",
manufacturer_name(con_edid + 0x08),
(unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),
(unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)
+ (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));
 
DRM_DEBUG_KMS("set mode %d %d: crtc %d connector %s\n",
reqmode->width, reqmode->height, crtc->base.id,
con_name);
 
drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
 
hdisplay = mode->hdisplay;
vdisplay = mode->vdisplay;
 
// if (crtc->invert_dimensions)
// swap(hdisplay, vdisplay);
 
fb = crtc->primary->fb;
if(fb == NULL)
fb = main_framebuffer;
 
fb->width = reqmode->width;
fb->height = reqmode->height;
 
main_fb_obj->tiling_mode = I915_TILING_X;
 
if( main_fb_obj->tiling_mode == I915_TILING_X)
{
if(IS_GEN3(dev))
for (stride = 512; stride < reqmode->width * 4; stride <<= 1);
else
stride = ALIGN(reqmode->width * 4, 512);
}
else
{
stride = ALIGN(reqmode->width * 4, 64);
}
 
fb->pitches[0] =
fb->pitches[1] =
fb->pitches[2] =
fb->pitches[3] = stride;
 
main_fb_obj->stride = stride;
 
fb->bits_per_pixel = 32;
fb->depth = 24;
 
crtc->enabled = true;
os_display->crtc = crtc;
 
DRM_DEBUG_KMS("fb:%p %dx%dx pitch %d format %x\n",
i915_gem_object_put_fence(main_fb_obj);
 
printf("fb:%p %dx%dx pitch %d format %x\n",
fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format);
 
set.crtc = crtc;
266,34 → 189,19
 
if ( !ret )
{
struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
struct kos_framebuffer *kfb = intel_fb->private;
kolibri_framebuffer_update(dev_priv, kfb);
DRM_DEBUG_KMS("kolibri framebuffer %p\n", kfb);
 
os_display->width = mode->hdisplay;
os_display->height = mode->vdisplay;
os_display->width = fb->width;
os_display->height = fb->height;
os_display->vrefresh = drm_mode_vrefresh(mode);
sysSetFramebuffer(intel_fb->private);
sysSetScreen(mode->hdisplay, mode->vdisplay, fb->pitches[0]);
 
os_display->connector = connector;
os_display->crtc = connector->encoder->crtc;
os_display->supported_modes = count_connector_modes(connector);
sysSetScreen(fb->width, fb->height, fb->pitches[0]);
 
crtc->cursor_x = os_display->width/2;
crtc->cursor_y = os_display->height/2;
 
os_display->select_cursor(os_display->cursor);
 
DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",
mode->hdisplay, mode->vdisplay, fb->pitches[0]);
fb->width, fb->height, fb->pitches[0]);
}
else
DRM_ERROR("failed to set mode %d_%d on crtc %p\n",
fb->width, fb->height, crtc);
 
drm_framebuffer_unreference(fb);
drm_modeset_unlock_all(dev);
 
return ret;
307,20 → 215,10
struct drm_mode_config *config = &dev->mode_config;
struct drm_framebuffer *fb = NULL;
struct drm_mode_set set;
struct drm_crtc *crtc = NULL;
 
char con_edid[128];
int stride;
int ret;
 
fb = get_framebuffer(dev, mode, 1);
if(fb == NULL)
{
DRM_ERROR("%s failed\n", __FUNCTION__);
return -1;
};
drm_framebuffer_reference(fb);
 
drm_modeset_lock_all(dev);
 
list_for_each_entry(tmpc, &dev->mode_config.connector_list, head)
331,12 → 229,47
f->dpms(tmpc, DRM_MODE_DPMS_OFF);
};
 
crtc = connector->encoder->crtc;
drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
 
fb = connector->encoder->crtc->primary->fb;
if(fb == NULL)
fb = main_framebuffer;
 
fb->width = mode->hdisplay;
fb->height = mode->vdisplay;;
 
main_fb_obj->tiling_mode = I915_TILING_X;
 
if( main_fb_obj->tiling_mode == I915_TILING_X)
{
if(IS_GEN3(dev))
for (stride = 512; stride < mode->hdisplay * 4; stride <<= 1);
else
stride = ALIGN(mode->hdisplay * 4, 512);
}
else
{
stride = ALIGN(mode->hdisplay * 4, 64);
}
 
fb->pitches[0] =
fb->pitches[1] =
fb->pitches[2] =
fb->pitches[3] = stride;
 
main_fb_obj->stride = stride;
 
fb->bits_per_pixel = 32;
fb->depth = 24;
 
connector->encoder->crtc->enabled = true;
 
i915_gem_object_put_fence(main_fb_obj);
 
memcpy(con_edid, connector->edid_blob_ptr->data, 128);
DRM_DEBUG_KMS("set mode %dx%d: crtc %d connector %s\n"
"monitor: %s model %x serial number %u\n",
mode->hdisplay, mode->vdisplay,
fb->width, fb->height,
connector->encoder->crtc->base.id, connector->name,
manufacturer_name(con_edid + 0x08),
(unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),
343,15 → 276,10
(unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)
+ (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));
 
drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
 
crtc->enabled = true;
os_display->crtc = crtc;
 
DRM_DEBUG_KMS("use framebuffer %p %dx%d pitch %d format %x\n",
fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format);
 
set.crtc = crtc;
set.crtc = connector->encoder->crtc;
set.x = 0;
set.y = 0;
set.mode = mode;
362,17 → 290,14
ret = drm_mode_set_config_internal(&set);
if ( !ret )
{
struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
struct kos_framebuffer *kfb = intel_fb->private;
kolibri_framebuffer_update(dev_priv, kfb);
DRM_DEBUG_KMS("kolibri framebuffer %p\n", kfb);
struct drm_crtc *crtc = os_display->crtc;
 
os_display->width = mode->hdisplay;
os_display->height = mode->vdisplay;
os_display->width = fb->width;
os_display->height = fb->height;
os_display->vrefresh = drm_mode_vrefresh(mode);
sysSetFramebuffer(intel_fb->private);
sysSetScreen(mode->hdisplay, mode->vdisplay, fb->pitches[0]);
 
sysSetScreen(fb->width, fb->height, fb->pitches[0]);
 
os_display->connector = connector;
os_display->crtc = connector->encoder->crtc;
os_display->supported_modes = count_connector_modes(connector);
380,17 → 305,17
crtc->cursor_x = os_display->width/2;
crtc->cursor_y = os_display->height/2;
 
os_display->select_cursor(os_display->cursor);
select_cursor_kms(os_display->cursor);
 
DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",
mode->hdisplay, mode->vdisplay, fb->pitches[0]);
fb->width, fb->height, fb->pitches[0]);
}
else
DRM_ERROR(" failed to set mode %d_%d on crtc %p\n",
fb->width, fb->height, connector->encoder->crtc);
 
drm_framebuffer_unreference(fb);
drm_modeset_unlock_all(dev);
 
return ret;
}
 
542,16 → 467,12
struct drm_connector_helper_funcs *connector_funcs;
struct drm_connector *connector = NULL;
struct drm_crtc *crtc = NULL;
struct drm_plane *plane;
struct drm_framebuffer *fb;
 
cursor_t *cursor;
u32 ifl;
int ret;
ENTER();
 
drm_for_each_plane(plane, dev)
{
drm_plane_helper_disable(plane);
};
 
mutex_lock(&dev->mode_config.mutex);
ret = choose_config(dev, &connector, &crtc);
if(ret)
561,9 → 482,9
return -1;
};
 
/*
mutex_lock(&dev->object_name_lock);
idr_preload(GFP_KERNEL);
 
if (!main_fb_obj->base.name) {
ret = idr_alloc(&dev->object_name_idr, &main_fb_obj->base, 1, 0, GFP_NOWAIT);
 
571,10 → 492,9
main_fb_obj->base.handle_count++;
DRM_DEBUG_KMS("%s allocate fb name %d\n", __FUNCTION__, main_fb_obj->base.name );
}
 
idr_preload_end();
mutex_unlock(&dev->object_name_lock);
*/
dummy_fb_page = AllocPage();
 
os_display = GetDisplay();
os_display->ddev = dev;
583,8 → 503,33
os_display->supported_modes = count_connector_modes(connector);
mutex_unlock(&dev->mode_config.mutex);
 
init_system_cursors(dev);
mutex_init(&cursor_lock);
mutex_lock(&dev->struct_mutex);
 
ifl = safe_cli();
{
list_for_each_entry(cursor, &os_display->cursors, list)
{
init_cursor(cursor);
};
 
os_display->restore_cursor(0,0);
os_display->init_cursor = init_cursor;
os_display->select_cursor = select_cursor_kms;
os_display->show_cursor = NULL;
os_display->move_cursor = move_cursor_kms;
os_display->restore_cursor = restore_cursor;
os_display->disable_mouse = disable_mouse;
 
crtc->cursor_x = os_display->width/2;
crtc->cursor_y = os_display->height/2;
 
select_cursor_kms(os_display->cursor);
};
safe_sti(ifl);
 
mutex_unlock(&dev->struct_mutex);
 
ret = -1;
 
if(connector->cmdline_mode.specified == true)
612,7 → 557,9
set_mode(dev, os_display->connector, os_display->crtc, usermode, false);
};
 
LEAVE();
#ifdef __HWA__
err = init_bitmaps();
#endif
 
return ret;
};
798,138 → 745,160
f->dpms(os_display->connector, mode);
};
 
 
int i915_fbinfo(struct drm_i915_fb_info *fb)
void __attribute__((regparm(1))) destroy_cursor(cursor_t *cursor)
{
u32 ifl;
struct drm_i915_gem_object *obj = cursor->cobj;
list_del(&cursor->list);
 
ifl = safe_cli();
i915_gem_object_ggtt_unpin(cursor->cobj);
 
mutex_lock(&main_device->struct_mutex);
drm_gem_object_unreference(&obj->base);
mutex_unlock(&main_device->struct_mutex);
 
__DestroyObject(cursor);
};
 
int init_cursor(cursor_t *cursor)
{
struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
struct intel_crtc *crtc = to_intel_crtc(os_display->crtc);
struct kos_framebuffer *kfb = os_display->current_lfb;
struct intel_framebuffer *intel_fb = (struct intel_framebuffer*)kfb->private;
struct drm_i915_gem_object *obj = intel_fb->obj;
struct drm_i915_gem_object *obj;
uint32_t *bits;
uint32_t *src;
void *mapped;
 
fb->name = obj->base.name;
fb->width = os_display->width;
fb->height = os_display->height;
fb->pitch = obj->stride;
fb->tiling = obj->tiling_mode;
fb->crtc = crtc->base.base.id;
fb->pipe = crtc->pipe;
int i,j;
int ret;
 
if (dev_priv->info.cursor_needs_physical)
{
bits = (uint32_t*)KernelAlloc(KMS_CURSOR_WIDTH*KMS_CURSOR_HEIGHT*8);
if (unlikely(bits == NULL))
return ENOMEM;
cursor->cobj = (struct drm_i915_gem_object *)GetPgAddr(bits);
}
safe_sti(ifl);
return 0;
else
{
obj = i915_gem_alloc_object(os_display->ddev, KMS_CURSOR_WIDTH*KMS_CURSOR_HEIGHT*4);
if (unlikely(obj == NULL))
return -ENOMEM;
 
ret = i915_gem_object_ggtt_pin(obj, &i915_ggtt_view_normal, 128*1024, PIN_GLOBAL);
if (ret) {
drm_gem_object_unreference(&obj->base);
return ret;
}
 
ret = i915_gem_object_set_to_gtt_domain(obj, true);
if (ret)
{
i915_gem_object_ggtt_unpin(obj);
drm_gem_object_unreference(&obj->base);
return ret;
}
/* You don't need to worry about fragmentation issues.
* GTT space is continuous. I guarantee it. */
 
int kolibri_framebuffer_init(struct intel_framebuffer *intel_fb)
mapped = bits = (u32*)MapIoMem(dev_priv->gtt.mappable_base + i915_gem_obj_ggtt_offset(obj),
KMS_CURSOR_WIDTH*KMS_CURSOR_HEIGHT*4, PG_SW);
 
if (unlikely(bits == NULL))
{
struct kos_framebuffer *kfb;
addr_t dummy_table;
addr_t *pt_addr = NULL;
int pde;
ENTER();
kfb = kzalloc(sizeof(struct kos_framebuffer),0);
kfb->private = intel_fb;
i915_gem_object_ggtt_unpin(obj);
drm_gem_object_unreference(&obj->base);
return -ENOMEM;
};
cursor->cobj = obj;
};
 
for(pde = 0; pde < 8; pde++)
src = cursor->data;
 
for(i = 0; i < 32; i++)
{
dummy_table = AllocPage();
kfb->pde[pde] = dummy_table|PG_UW;
for(j = 0; j < 32; j++)
*bits++ = *src++;
for(j = 32; j < KMS_CURSOR_WIDTH; j++)
*bits++ = 0;
}
for(i = 0; i < KMS_CURSOR_WIDTH*(KMS_CURSOR_HEIGHT-32); i++)
*bits++ = 0;
 
pt_addr = kmap((st