Subversion Repositories Kolibri OS

#include 

#include "i915_drv.h"

#include "intel_drv.h"

#include 

#include 

#include 

#include 

void kolibri_framebuffer_update(struct drm_i915_private *dev_priv, struct kos_framebuffer *kfb);

void init_system_cursors(struct drm_device *dev);

u32 cmd_offset;

int  sna_init();

{

    static char name[4];

    name[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@';

    name[2] = (x[1] & 0x1F) + '@';

    name[3] = 0;

}

{

    struct drm_display_mode  *mode;

    int count = 0;

        count++;

};

{

    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;

    {

        int gen3size;

            for (stride = 512; stride < mode->hdisplay * 4; stride <<= 1);

        else

            stride = ALIGN(stride, 512);

        size = stride * ALIGN(mode->vdisplay, 8);

        {

            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);

    }

    {

        struct drm_mode_fb_cmd2 mode_cmd = {};

        int ret;

        drm_framebuffer_remove(fb);

        ifbdev->fb = NULL;

        fb = NULL;

        DRM_DEBUG_KMS("create new framebuffer\n");

        mode_cmd.height = mode->vdisplay;

        mode_cmd.pixel_format = DRM_FORMAT_XRGB8888;

        * 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;

        }

        if (IS_ERR(fb)) {

            ret = PTR_ERR(fb);

            goto out_unref;

        }

        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->tiling_mode = I915_TILING_X;

        fb->modifier[0]  = I915_FORMAT_MOD_X_TILED;

        obj->fence_dirty = true;

        obj->stride      = stride;

    };

    {

        int ret;

        idr_preload(GFP_KERNEL);

        ret = idr_alloc(&dev->object_name_idr, &obj->base, 1, 0, GFP_NOWAIT);

        idr_preload_end();

        mutex_unlock(&dev->object_name_lock);

        obj->base.name = ret;

        obj->base.handle_count++;

        DRM_DEBUG_KMS("%s allocate fb name %d\n", __FUNCTION__, obj->base.name );

    }

    fb->height = mode->vdisplay;

    fb->pitches[1]  =

    fb->pitches[2]  =

    fb->pitches[3]  = stride;

    fb->depth = 24;

LEAVE();

    return fb;

    drm_framebuffer_remove(fb);

out_unref:

    drm_gem_object_unreference(&obj->base);

out:

    mutex_unlock(&dev->struct_mutex);

    return NULL;

}

                    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];

    int ret;

    {

        const struct drm_connector_funcs *f = tmpc->funcs;

        if(tmpc == connector)

            continue;

        f->dpms(tmpc, DRM_MODE_DPMS_OFF);

    };

    {

        if( (tmpmode->hdisplay == reqmode->width)  &&

            (tmpmode->vdisplay == reqmode->height) &&

            (drm_mode_vrefresh(tmpmode) == reqmode->freq) )

        {

            mode = tmpmode;

            goto do_set;

        }

    };

    {

        list_for_each_entry(tmpmode, &connector->modes, head)

        {

            if( (tmpmode->hdisplay == reqmode->width)  &&

                (tmpmode->vdisplay == reqmode->height) )

            {

                mode = tmpmode;

                goto do_set;

            }

        };

    };

    drm_modeset_unlock_all(dev);

    DRM_ERROR("%s failed\n", __FUNCTION__);

    return -1;

    if(fb == NULL)

    {

        DRM_ERROR("%s failed\n", __FUNCTION__);

        return -1;

    };

    drm_framebuffer_reference(fb);

                  "monitor: %s model %x serial number %u\n",

                mode->hdisplay, mode->vdisplay,

                crtc->base.id, connector->name,

                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)));

    os_display->crtc = crtc;

            fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format);

    set.x = 0;

    set.y = 0;

    set.mode = mode;

    set.connectors = &connector;

    set.num_connectors = 1;

    set.fb = fb;

    {

        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->height   = mode->vdisplay;

        os_display->vrefresh = drm_mode_vrefresh(mode);

        sysSetFramebuffer(intel_fb->private);

        sysSetScreen(mode->hdisplay, mode->vdisplay, fb->pitches[0]);

        os_display->crtc = connector->encoder->crtc;

        os_display->supported_modes = count_connector_modes(connector);

        crtc->cursor_y = os_display->height/2;

                       mode->hdisplay, mode->vdisplay, fb->pitches[0]);

    }

    else

        DRM_ERROR("failed to set mode %d_%d on crtc %p\n",

                   fb->width, fb->height, crtc);

    drm_modeset_unlock_all(dev);

}

                       struct drm_connector *connector, struct drm_display_mode *mode)

{

    struct drm_i915_private *dev_priv = dev->dev_private;

    struct drm_connector    *tmpc;

    struct drm_mode_config  *config   = &dev->mode_config;

    struct drm_framebuffer  *fb       = NULL;

    struct drm_mode_set     set;

    struct drm_crtc *crtc = NULL;

    int stride;

    int ret;

    if(fb == NULL)

    {

        DRM_ERROR("%s failed\n", __FUNCTION__);

        return -1;

    };

    drm_framebuffer_reference(fb);

    {

        const struct drm_connector_funcs *f = tmpc->funcs;

        if(tmpc == connector)

            continue;

        f->dpms(tmpc, DRM_MODE_DPMS_OFF);

    };

    DRM_DEBUG_KMS("set mode %dx%d: crtc %d connector %s\n"

                  "monitor: %s model %x serial number %u\n",

                mode->hdisplay, mode->vdisplay,

                connector->encoder->crtc->base.id, connector->name,

                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)));

    os_display->crtc = crtc;

            fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format);

    set.x = 0;

    set.y = 0;

    set.mode = mode;

    set.connectors = &connector;

    set.num_connectors = 1;

    set.fb = fb;

    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->height   = mode->vdisplay;

        os_display->vrefresh = drm_mode_vrefresh(mode);

        sysSetFramebuffer(intel_fb->private);

        sysSetScreen(mode->hdisplay, mode->vdisplay, fb->pitches[0]);

        os_display->crtc = connector->encoder->crtc;

        os_display->supported_modes = count_connector_modes(connector);

        crtc->cursor_y = os_display->height/2;

                       mode->hdisplay, mode->vdisplay, fb->pitches[0]);

    }

    else

        DRM_ERROR(" failed to set mode %d_%d on crtc %p\n",

                   fb->width, fb->height, connector->encoder->crtc);

    drm_modeset_unlock_all(dev);

    return ret;

}

{

    struct drm_display_mode *mode;

    int retval;

    if(mode == NULL)

        return EINVAL;

    return retval;

};

{

    struct drm_crtc *tmp_crtc;

    int crtc_mask = 1;

    {

        if (encoder->possible_crtcs & crtc_mask)

        {

            encoder->crtc = tmp_crtc;

            DRM_DEBUG_KMS("use CRTC %p ID %d\n", tmp_crtc, tmp_crtc->base.id);

            return tmp_crtc;

        };

        crtc_mask <<= 1;

    };

    return NULL;

};

{

    const struct drm_connector_helper_funcs *connector_funcs;

    struct drm_encoder   *encoder;

    struct drm_crtc      *crtc;

        return -EINVAL;

    {

        connector_funcs = connector->helper_private;

        encoder = connector_funcs->best_encoder(connector);

        {

            DRM_DEBUG_KMS("CONNECTOR %s ID: %d no active encoders\n",

            connector->name, connector->base.id);

            return -EINVAL;

        };

        connector->encoder = encoder;

    }

    if(crtc == NULL)

        crtc = get_possible_crtc(dev, encoder);

    {

        DRM_DEBUG_KMS("%s connector: %p encode: %p crtc: %p\n",__FUNCTION__,

               connector, encoder, crtc);

        return 0;

    }

    else

        DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id);

    return -EINVAL;

}

{

    struct drm_connector *connector;

    {

        int name_len = __builtin_strlen(connector->name);

            continue;

            continue;

            return connector;

    }

    return NULL;

}

                  struct drm_crtc **boot_crtc)

{

    struct drm_connector *connector;

    {

        connector = get_cmdline_connector(dev, i915.cmdline_mode);

        if(connector != NULL)

        {

            *boot_connector = connector;

            *boot_crtc = connector->encoder->crtc;

            return 0;

        }

    }

    {

        if(check_connector(dev, connector) == 0)

        {

            *boot_connector = connector;

            *boot_crtc = connector->encoder->crtc;

            return 0;

        };

    };

};

{

    struct drm_display_mode *mode;

    {

        if( os_display->width  == mode->hdisplay &&

            os_display->height == mode->vdisplay &&

            drm_mode_vrefresh(mode) == 60)

        {

            usermode->width  = os_display->width;

            usermode->height = os_display->height;

            usermode->freq   = 60;

            return 1;

        }

    }

    return 0;

}

{

    struct drm_connector_helper_funcs *connector_funcs;

    struct drm_connector    *connector = NULL;

    struct drm_crtc         *crtc = NULL;

    struct drm_plane *plane;

ENTER();

    {

        drm_plane_helper_disable(plane);

    };

    ret = choose_config(dev, &connector, &crtc);

    if(ret)

    {

        mutex_unlock(&dev->mode_config.mutex);

        DRM_DEBUG_KMS("No active connectors!\n");

        return -1;

    };

    os_display->ddev = dev;

    os_display->connector = connector;

    os_display->crtc = crtc;

    os_display->supported_modes = count_connector_modes(connector);

    mutex_unlock(&dev->mode_config.mutex);

        ret = set_cmdline_mode(dev, connector);

    {

        mutex_lock(&dev->mode_config.mutex);

            (usermode->height == 0))

        {

            if( !get_boot_mode(connector, usermode))

            {

                struct drm_display_mode *mode;

                usermode->width  = mode->hdisplay;

                usermode->height = mode->vdisplay;

                usermode->freq   = drm_mode_vrefresh(mode);

            };

        };

        mutex_unlock(&dev->mode_config.mutex);

    };

};

{

    struct drm_connector_helper_funcs *connector_funcs;

    struct drm_connector    *connector;

    struct drm_cmdline_mode cmd_mode = {0};

    struct drm_display_mode *mode;

    char *mode_option;

    int retval = 0;

    char  con_edid[128];

        return EINVAL;

    connector = get_cmdline_connector(dev, cmdline);

    mutex_unlock(&dev->mode_config.mutex);

        return EINVAL;

    if(mode_option == NULL)

        return EINVAL;

        return EINVAL;

                   connector->name,

                   cmd_mode.xres, cmd_mode.yres,

                   cmd_mode.refresh_specified ? cmd_mode.refresh : 60,

                   cmd_mode.rb ? " reduced blanking" : "",

                   cmd_mode.margins ? " with margins" : "",

                   cmd_mode.interlace ?  " interlaced" : "");

    if(mode == NULL)

        return EINVAL;

    DRM_DEBUG_KMS("connector: %s monitor: %s model %x serial number %u\n",

            connector->name,

            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)));

}

{

    struct drm_connector *connector;

    char  con_edid[128];

    list_for_each_entry(connector, &dev->mode_config.connector_list, head)

    {

        if( connector->status != connector_status_connected)

            continue;

        {

            printf("%s mode %dx%d connected %s model %x serial number %u\n",

                   connector->name, os_display->width, os_display->height,

                   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)));

            continue;

        }

        else

        {

            printf("%s connected: %s model %x serial number %u\n",

                connector->name, 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)));

        }

    };

    mutex_unlock(&dev->mode_config.mutex);

}

{

    struct drm_connector *connector;

    struct drm_display_mode  *drmmode;

    if(connector == NULL)

    {

        mutex_unlock(&dev->mode_config.mutex);

        return EINVAL;

    };

    {

        printf("%dx%d@%d\n", drmmode->hdisplay, drmmode->vdisplay, drm_mode_vrefresh(drmmode));

    };

    return 0;

};

{

    int err = -1;

    {

        *count = os_display->supported_modes;

        err = 0;

    }

    else if( mode != NULL )

    {

        struct drm_display_mode  *drmmode;

        int i = 0;

            *count = os_display->supported_modes;

        {

            if( i < *count)

            {

                mode->width  = drmmode->hdisplay;

                mode->height = drmmode->vdisplay;

                mode->bpp    = 32;

                mode->freq   = drm_mode_vrefresh(drmmode);

                i++;

                mode++;

            }

            else break;

        };

        *count = i;

        err = 0;

    };

    return err;

};

{

//               mode->width, mode->height, mode->freq);

        (mode->height != 0)  &&

        (mode->freq   != 0 ) &&

        ( (mode->width   != os_display->width)  ||

          (mode->height  != os_display->height) ||

          (mode->freq    != os_display->vrefresh) ) )

    {

        return set_mode(os_display->ddev, os_display->connector, os_display->crtc, mode, true);

    };

};

{

    const struct drm_connector_funcs *f = os_display->connector->funcs;

};

{

    u32 ifl;

    {

        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;

        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;

    }

    safe_sti(ifl);

}

{

    struct kos_framebuffer *kfb;

    addr_t dummy_table;

    addr_t *pt_addr = NULL;

    int pde;

    kfb->private = intel_fb;

    {

        dummy_table = AllocPage();

        kfb->pde[pde] = dummy_table|PG_UW;

        __builtin_memset(pt_addr,0,4096);

        kunmap((struct page*)dummy_table);

    };

#if 0

    struct sg_page_iter sg_iter;

    num_pages = obj->base.size/4096;

    printf("num_pages %d\n",num_pages);

    pde = 0;

    pt_addr = NULL;

    while (__sg_page_iter_next(&sg_iter))

    {

        if (pt_addr == NULL)

        {

            addr_t pt = AllocPage();

            kfb->pde[pde] = pt|PG_UW;

            pde++;

            pt_addr = kmap_atomic((struct page*)pt);

        }

        pt_addr[pte] = sg_page_iter_dma_address(&sg_iter)|PG_UW|PG_WRITEC;

        if( (pte & 15) == 0)

            DRM_DEBUG_KMS("pte %x\n",pt_addr[pte]);

        if (++pte == 1024)

        {

            kunmap_atomic(pt_addr);

            pt_addr = NULL;

            if (pde == 8)

                break;

            pte = 0;

        }

    }

    {

        for(;pte < 1024; pte++)

            pt_addr[pte] = dummy_page|PG_UW;

        kunmap_atomic(pt_addr);

    }

#endif

};

{

    struct intel_framebuffer *intel_fb = kfb->private;

    addr_t *pt_addr = NULL;

    int pte = 0;

    int pde = 0;

    int num_pages;

    addr_t pfn;

ENTER();

    num_pages = intel_fb->obj->base.size/4096;

    pfn = dev_priv->gtt.mappable_base + i915_gem_obj_ggtt_offset(intel_fb->obj);

    {

        if (pt_addr == NULL)

        {

            addr_t pt = kfb->pde[pde] & 0xFFFFF000;

            pde++;

            pt_addr = kmap_atomic((struct page*)pt);

        }

        pt_addr[pte] = pfn|PG_UW|PG_WRITEC;

        pfn+= 4096;

        num_pages--;

        if (++pte == 1024)

        {

            kunmap_atomic(pt_addr);

            pt_addr = NULL;

            if (pde == 8)

                break;

            pte = 0;

        }

    }

    {

        for(;pte < 1024; pte++)

            pt_addr[pte] = dummy_fb_page|PG_UW;

        kunmap_atomic(pt_addr);

    }

LEAVE();

};

{

    int left;

    int top;

    int right;

    int bottom;

}rect_t;

            struct drm_file *file)

{

    struct drm_i915_mask *mask = data;

    struct drm_gem_object *obj;

    static unsigned int mask_seqno[256];

    rect_t winrc;

    u32    slot;

    int    ret=0;

    if (obj == NULL)

        return -ENOENT;

        drm_gem_object_unreference_unlocked(obj);

        return -EINVAL;

    }

    {

//        static warn_count;

        mask->height   = winrc.bottom - winrc.top + 1;

        mask->bo_pitch = (mask->width+15) & ~15;

        if(warn_count < 1)

        {

            printf("left %d top %d right %d bottom %d\n",

                    winrc.left, winrc.top, winrc.right, winrc.bottom);

            printf("mask pitch %d data %p\n", mask->bo_pitch, mask->bo_map);

            warn_count++;

        };

#endif

    {

        u8* src_offset;

        u8* dst_offset;

        u32 ifl;

        if (ret)

            goto err1;

        if(ret != 0 )

        {

            dbgprintf("%s: i915_gem_object_set_to_cpu_domain failed\n", __FUNCTION__);

            goto err2;

        };

        src_offset+= winrc.top*os_display->width + winrc.left;

        {

            mask_seqno[slot] = os_display->mask_seqno;

            "movd       %[slot],   %%xmm6         \n"

            "punpckldq  %%xmm6, %%xmm6            \n"

            "punpcklqdq %%xmm6, %%xmm6            \n"

            :: [slot]  "m" (slot)

            :"xmm6");

            {

                int tmp_w = mask->width;

                u8* tmp_dst = dst_offset;

                dst_offset+= mask->bo_pitch;

                {

                    __asm__ __volatile__ (

                    "movdqu     (%0),   %%xmm0            \n"

                    "movdqu   16(%0),   %%xmm1            \n"

                    "movdqu   32(%0),   %%xmm2            \n"

                    "movdqu   48(%0),   %%xmm3            \n"

                    "pcmpeqb    %%xmm6, %%xmm0            \n"

                    "pcmpeqb    %%xmm6, %%xmm1            \n"

                    "pcmpeqb    %%xmm6, %%xmm2            \n"

                    "pcmpeqb    %%xmm6, %%xmm3            \n"

                    "movdqa     %%xmm0,   (%%edi)         \n"

                    "movdqa     %%xmm1, 16(%%edi)         \n"

                    "movdqa     %%xmm2, 32(%%edi)         \n"

                    "movdqa     %%xmm3, 48(%%edi)         \n"

                    :"xmm0","xmm1","xmm2","xmm3");

                    tmp_w -= 64;

                    tmp_src += 64;

                    tmp_dst += 64;

                }

                {

                    __asm__ __volatile__ (

                    "movdqu     (%0),   %%xmm0            \n"

                    "movdqu   16(%0),   %%xmm1            \n"

                    "pcmpeqb    %%xmm6, %%xmm0            \n"

                    "pcmpeqb    %%xmm6, %%xmm1            \n"

                    "movdqa     %%xmm0,   (%%edi)         \n"

                    "movdqa     %%xmm1, 16(%%edi)         \n"

                    :"xmm0","xmm1");

                    tmp_w -= 32;

                    tmp_src += 32;

                    tmp_dst += 32;

                }

                {

                    __asm__ __volatile__ (

                    "movdqu     (%0),   %%xmm0            \n"

                    "pcmpeqb    %%xmm6, %%xmm0            \n"

                    "movdqa     %%xmm0,   (%%edi)         \n"

                    :: "r" (tmp_src), "D" (tmp_dst)

                    :"xmm0");

                    tmp_w -= 16;