WebSVN – Kolibri OS – Diff – /drivers/video/drm/i915/kms_display.c


#define iowrite32(v, addr)      writel((v), (addr))
 
#include 
#include 
#include "i915_drv.h"
#include "intel_drv.h"
#include 
#include 
#include 
 
#include 
 
#include "bitmap.h"
#include 
 
 
display_t *os_display;
struct drm_i915_gem_object *main_fb_obj;
struct drm_framebuffer     *main_framebuffer;
 
u32 cmd_buffer;
u32 cmd_offset;
 
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];
 
    name[0] = ((x[0] & 0x7C) >> 2) + '@';
    name[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@';
    name[2] = (x[1] & 0x1F) + '@';
    name[3] = 0;
 
    return name;
}
 
static int count_connector_modes(struct drm_connector* connector)
{
    struct drm_display_mode  *mode;
    int count = 0;
 
    list_for_each_entry(mode, &connector->modes, head)
        count++;
 
    return count;
};
 
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;
    const char *con_name;
    unsigned hdisplay, vdisplay;
    int stride;
    int ret;
 
 
 
    drm_modeset_lock_all(dev);
 
    list_for_each_entry(tmpc, &dev->mode_config.connector_list, head)
    {
        const struct drm_connector_funcs *f = tmpc->funcs;
        if(tmpc == connector)
            continue;
        f->dpms(tmpc, DRM_MODE_DPMS_OFF);
    };
 
    list_for_each_entry(tmpmode, &connector->modes, head)
    {
        if( (tmpmode->hdisplay == reqmode->width)  &&
            (tmpmode->vdisplay == reqmode->height) &&
            (drm_mode_vrefresh(tmpmode) == reqmode->freq) )
        {
            mode = tmpmode;
            goto do_set;
        }
    };
 
    if( (mode == NULL) && (strict == false) )
    {
        list_for_each_entry(tmpmode, &connector->modes, head)
        {
            if( (tmpmode->hdisplay == reqmode->width)  &&
                (tmpmode->vdisplay == reqmode->height) )
            {
                mode = tmpmode;
                goto do_set;
            }
        };
    };
 
    DRM_ERROR("%s failed\n", __FUNCTION__);
 
    return -1;
 
do_set:
 
 
    con_name = connector->name;
 
    char  con_edid[128];
 
    memcpy(con_edid, connector->edid_blob_ptr->data, 128);
    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;
 
    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;
    set.x = 0;
    set.y = 0;
    set.mode = mode;
    set.connectors = &connector;
    set.num_connectors = 1;
    set.fb = fb;
 
    ret = drm_mode_set_config_internal(&set);
 
    if ( !ret )
    {
        os_display->width    = fb->width;
        os_display->height   = fb->height;
        os_display->vrefresh = drm_mode_vrefresh(mode);
 
        sysSetScreen(fb->width, fb->height, fb->pitches[0]);
 
        DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",
                       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_modeset_unlock_all(dev);
 
 
 
    return ret;
}
 
static int set_mode_ex(struct drm_device *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;
    char  con_edid[128];
    int stride;
    int ret;
 
 
 
    drm_modeset_lock_all(dev);
 
    list_for_each_entry(tmpc, &dev->mode_config.connector_list, head)
    {
        const struct drm_connector_funcs *f = tmpc->funcs;
        if(tmpc == connector)
            continue;
        f->dpms(tmpc, DRM_MODE_DPMS_OFF);
    };
 
    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",
                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)),
                (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)
                + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));
 
    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 = connector->encoder->crtc;
    set.x = 0;
    set.y = 0;
    set.mode = mode;
    set.connectors = &connector;
    set.num_connectors = 1;
    set.fb = fb;
 
    ret = drm_mode_set_config_internal(&set);
    if ( !ret )
    {
        struct drm_crtc *crtc = os_display->crtc;
 
        os_display->width    = fb->width;
        os_display->height   = fb->height;
        os_display->vrefresh = drm_mode_vrefresh(mode);
 
        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);
 
        crtc->cursor_x = os_display->width/2;
        crtc->cursor_y = os_display->height/2;
 
        select_cursor_kms(os_display->cursor);
 
        DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",
                       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_modeset_unlock_all(dev);
 
 
 
    return ret;
}
 
static int set_cmdline_mode(struct drm_device *dev, struct drm_connector *connector)
{
    struct drm_display_mode *mode;
    int retval;
 
    mode = drm_mode_create_from_cmdline_mode(dev, &connector->cmdline_mode);
    if(mode == NULL)
        return EINVAL;
 
    retval = set_mode_ex(dev, connector, mode);
 
    drm_mode_destroy(dev, mode);
    return retval;
};
 
static struct drm_crtc *get_possible_crtc(struct drm_device *dev, struct drm_encoder *encoder)
{
    struct drm_crtc *tmp_crtc;
    int crtc_mask = 1;
 
    list_for_each_entry(tmp_crtc, &dev->mode_config.crtc_list, head)
    {
        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;
};
 
static int check_connector(struct drm_device *dev, struct drm_connector *connector)
{
    const struct drm_connector_helper_funcs *connector_funcs;
    struct drm_encoder   *encoder;
    struct drm_crtc      *crtc;
 
    if( connector->status != connector_status_connected)
        return -EINVAL;
 
    encoder = connector->encoder;
 
    if(encoder == NULL)
    {
        connector_funcs = connector->helper_private;
        encoder = connector_funcs->best_encoder(connector);
 
        if( encoder == NULL)
        {
            DRM_DEBUG_KMS("CONNECTOR %s ID: %d no active encoders\n",
            connector->name, connector->base.id);
            return -EINVAL;
        };
    }
 
    crtc = encoder->crtc;
    if(crtc == NULL)
        crtc = get_possible_crtc(dev, encoder);
 
    if(crtc != NULL)
    {
        encoder->crtc = crtc;
        return 0;
    }
    else
        DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id);
    return -EINVAL;
}
 
static struct drm_connector* get_cmdline_connector(struct drm_device *dev, const char *cmdline)
{
    struct drm_connector *connector;
 
    list_for_each_entry(connector, &dev->mode_config.connector_list, head)
    {
        int name_len = __builtin_strlen(connector->name);
 
        if (name_len == 0)
            continue;
 
        if (__builtin_strncmp(connector->name, cmdline, name_len))
            continue;
 
        if(check_connector(dev, connector) == 0)
            return connector;
    }
    return NULL;
}
 
 
static int choose_config(struct drm_device *dev, struct drm_connector **boot_connector,
                  struct drm_crtc **boot_crtc)
{
    struct drm_connector *connector;
 
 
 
 
    if((i915.cmdline_mode != NULL) && (*i915.cmdline_mode != 0))
    {
        connector = get_cmdline_connector(dev, i915.cmdline_mode);
        if(connector != NULL)
        {
            *boot_connector = connector;
            *boot_crtc = connector->encoder->crtc;
            return 0;
        }
    }
 
    list_for_each_entry(connector, &dev->mode_config.connector_list, head)
    {
        if(check_connector(dev, connector) == 0)
        {
            *boot_connector = connector;
            *boot_crtc = connector->encoder->crtc;
            return 0;
        };
    };
 
    return -ENOENT;
};
 
 
static int get_boot_mode(struct drm_connector *connector, videomode_t *usermode)
{
    struct drm_display_mode *mode;
 
    list_for_each_entry(mode, &connector->modes, head)
    {
        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;
}
 
int init_display_kms(struct drm_device *dev, videomode_t *usermode)
{
    struct drm_connector_helper_funcs *connector_funcs;
    struct drm_connector    *connector = NULL;
    struct drm_crtc         *crtc = NULL;
    struct drm_framebuffer  *fb;
 
    cursor_t  *cursor;
    u32      ifl;
    int       ret;
 
 
 
    mutex_lock(&dev->mode_config.mutex);
    ret = choose_config(dev, &connector, &crtc);
    if(ret)
    {
        mutex_unlock(&dev->mode_config.mutex);
        DRM_DEBUG_KMS("No active connectors!\n");
        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);
 
        main_fb_obj->base.name = ret;
        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);
 
    os_display = GetDisplay();
    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);
 
    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)
        ret = set_cmdline_mode(dev, connector);
 
    if(ret !=0)
    {
        mutex_lock(&dev->mode_config.mutex);
 
        if( (usermode->width == 0) ||
            (usermode->height == 0))
        {
            if( !get_boot_mode(connector, usermode))
            {
                struct drm_display_mode *mode;
 
                mode = list_entry(connector->modes.next, typeof(*mode), head);
                usermode->width  = mode->hdisplay;
                usermode->height = mode->vdisplay;
                usermode->freq   = drm_mode_vrefresh(mode);
            };
        };
        mutex_unlock(&dev->mode_config.mutex);
 
        set_mode(dev, os_display->connector, os_display->crtc, usermode, false);
    };
 
#ifdef __HWA__
    err = init_bitmaps();
#endif
 
 
 
    return ret;
};
 
 
int set_cmdline_mode_ext(struct drm_device *dev, const char *cmdline)
{
    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];
 
 
    if((cmdline == NULL) || (*cmdline == 0))
        return EINVAL;
 
    mutex_lock(&dev->mode_config.mutex);
    connector = get_cmdline_connector(dev, cmdline);
    mutex_unlock(&dev->mode_config.mutex);
 
    if(connector == NULL)
        return EINVAL;
 
    mode_option = __builtin_strchr(cmdline,':');
    if(mode_option == NULL)
        return EINVAL;
 
    mode_option++;
 
 
 
    if( !drm_mode_parse_command_line_for_connector(mode_option, connector, &cmd_mode))
        return EINVAL;
 
    DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
                   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" : "");
 
    mode = drm_mode_create_from_cmdline_mode(dev, &cmd_mode);
    if(mode == NULL)
        return EINVAL;
 
    memcpy(con_edid, connector->edid_blob_ptr->data, 128);
    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)));
 
    retval = set_mode_ex(dev, connector, mode);
 
    drm_mode_destroy(dev, mode);
 
 
    return retval;
}
 
void list_connectors(struct drm_device *dev)
{
    struct drm_connector *connector;
    char  con_edid[128];
 
    mutex_lock(&dev->mode_config.mutex);
    list_for_each_entry(connector, &dev->mode_config.connector_list, head)
    {
        if( connector->status != connector_status_connected)
            continue;
 
        memcpy(con_edid, connector->edid_blob_ptr->data, 128);
 
        if(connector ==  os_display->connector)
        {
            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);
}
 
int list_connector_modes(struct drm_device *dev, const char* name)
{
    struct drm_connector *connector;
    struct drm_display_mode  *drmmode;
 
    mutex_lock(&dev->mode_config.mutex);
 
    connector = get_cmdline_connector(dev, name);
    if(connector == NULL)
    {
        mutex_unlock(&dev->mode_config.mutex);
        return EINVAL;
    };
 
    printf("connector %s probed modes :\n", connector->name);
 
    list_for_each_entry(drmmode, &connector->modes, head)
    {
        printf("%dx%d@%d\n", drmmode->hdisplay, drmmode->vdisplay, drm_mode_vrefresh(drmmode));
    };
 
    mutex_unlock(&dev->mode_config.mutex);
    return 0;
};
 
int get_videomodes(videomode_t *mode, int *count)
{
    int err = -1;
 
//    dbgprintf("mode %x count %d\n", mode, *count);
 
    if( *count == 0 )
    {
        *count = os_display->supported_modes;
        err = 0;
    }
    else if( mode != NULL )
    {
        struct drm_display_mode  *drmmode;
        int i = 0;
 
        if( *count > os_display->supported_modes)
            *count = os_display->supported_modes;
 
        list_for_each_entry(drmmode, &os_display->connector->modes, head)
        {
            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;
};
 
int set_user_mode(videomode_t *mode)
{
 
//    dbgprintf("width %d height %d vrefresh %d\n",
//               mode->width, mode->height, mode->freq);
 
    if( (mode->width  != 0)  &&
        (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);
    };
 
    return -1;
};
 
void i915_dpms(struct drm_device *dev, int mode)
{
    const struct drm_connector_funcs *f = os_display->connector->funcs;
 
    f->dpms(os_display->connector, mode);
};
 
void __attribute__((regparm(1))) destroy_cursor(cursor_t *cursor)
{
    struct drm_i915_gem_object *obj = cursor->cobj;
    list_del(&cursor->list);
 
    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 drm_i915_gem_object *obj;
    uint32_t *bits;
    uint32_t *src;
    void     *mapped;
 
    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);
    }
    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.                           */
 
        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))
        {
            i915_gem_object_ggtt_unpin(obj);
            drm_gem_object_unreference(&obj->base);
            return -ENOMEM;
        };
        cursor->cobj = obj;
    };
 
    src = cursor->data;
 
    for(i = 0; i < 32; i++)
    {
        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;
 
    FreeKernelSpace(mapped);
 
// release old cursor
 
    KernelFree(cursor->data);
 
    cursor->data = bits;
 
    cursor->header.destroy = destroy_cursor;
 
    return 0;
}
 
 
void __stdcall move_cursor_kms(cursor_t *cursor, int x, int y)
{
    struct drm_crtc *crtc = os_display->crtc;
    struct drm_plane_state *cursor_state = crtc->cursor->state;
 
    x-= cursor->hot_x;
    y-= cursor->hot_y;
 
	crtc->cursor_x = x;
	crtc->cursor_y = y;
 
    cursor_state->crtc_x = x;
    cursor_state->crtc_y = y;
 
	intel_crtc_update_cursor(crtc, 1);
 
};
 
cursor_t* __stdcall select_cursor_kms(cursor_t *cursor)
{
    struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
    struct drm_crtc   *crtc = os_display->crtc;
    struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
 
    cursor_t *old;
 
    old = os_display->cursor;
 
    mutex_lock(&cursor_lock);
 
    os_display->cursor = cursor;
 
    if (!dev_priv->info.cursor_needs_physical)
       intel_crtc->cursor_addr = i915_gem_obj_ggtt_offset(cursor->cobj);
    else
        intel_crtc->cursor_addr = (addr_t)cursor->cobj;
 
	intel_crtc->base.cursor->state->crtc_w = 64;
	intel_crtc->base.cursor->state->crtc_h = 64;
    intel_crtc->base.cursor->state->rotation = 0;
    mutex_unlock(&cursor_lock);
 
    move_cursor_kms(cursor, crtc->cursor_x, crtc->cursor_y);
    return old;
};
 
int i915_fbinfo(struct drm_i915_fb_info *fb)
{
    struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
    struct intel_crtc *crtc = to_intel_crtc(os_display->crtc);
    struct drm_i915_gem_object *obj = get_fb_obj();
 
    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;
 
    return 0;
}
 
 
typedef struct
{
    int left;
    int top;
    int right;
    int bottom;
}rect_t;
 
 
#define CURRENT_TASK             (0x80003000)
 
void  FASTCALL GetWindowRect(rect_t *rc)__asm__("GetWindowRect");
 
int i915_mask_update(struct drm_device *dev, void *data,
            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;
 
    obj = drm_gem_object_lookup(dev, file, mask->handle);
    if (obj == NULL)
        return -ENOENT;
 
    if (!obj->filp) {
        drm_gem_object_unreference_unlocked(obj);
        return -EINVAL;
    }
 
    GetWindowRect(&winrc);
    {
//        static warn_count;
 
        mask->width    = winrc.right - winrc.left + 1;
        mask->height   = winrc.bottom - winrc.top + 1;
        mask->bo_pitch = (mask->width+15) & ~15;
 
#if 0
        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
 
     };
 
 
    slot = *((u8*)CURRENT_TASK);
 
    if( mask_seqno[slot] != os_display->mask_seqno)
    {
        u8* src_offset;
        u8* dst_offset;
        u32 ifl;
 
        ret = i915_mutex_lock_interruptible(dev);
        if (ret)
            goto err1;
 
        ret = i915_gem_object_set_to_cpu_domain(to_intel_bo(obj), true);
        if(ret != 0 )
        {
            dbgprintf("%s: i915_gem_object_set_to_cpu_domain failed\n", __FUNCTION__);
            goto err2;
        };
 
//        printf("width %d height %d\n", winrc.right, winrc.bottom);
 
//        slot = 0x01;
 
        src_offset = os_display->win_map;
        src_offset+= winrc.top*os_display->width + winrc.left;
 
        dst_offset = (u8*)mask->bo_map;
 
        u32 tmp_h = mask->height;
 
        ifl = safe_cli();
        {
            mask_seqno[slot] = os_display->mask_seqno;
 
            slot|= (slot<<8)|(slot<<16)|(slot<<24);
 
            __asm__ __volatile__ (
            "movd       %[slot],   %%xmm6         \n"
            "punpckldq  %%xmm6, %%xmm6            \n"
            "punpcklqdq %%xmm6, %%xmm6            \n"
            :: [slot]  "m" (slot)
            :"xmm6");
 
            while( tmp_h--)
            {
                int tmp_w = mask->width;
 
                u8* tmp_src = src_offset;
                u8* tmp_dst = dst_offset;
 
                src_offset+= os_display->width;
                dst_offset+= mask->bo_pitch;
 
                while(tmp_w >= 64)
                {
                    __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"
 
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0","xmm1","xmm2","xmm3");
                    tmp_w -= 64;
                    tmp_src += 64;
                    tmp_dst += 64;
                }
 
                if( tmp_w >= 32 )
                {
                    __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"
 
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0","xmm1");
                    tmp_w -= 32;
                    tmp_src += 32;
                    tmp_dst += 32;
                }
 
                if( tmp_w >= 16 )
                {
                    __asm__ __volatile__ (
                    "movdqu     (%0),   %%xmm0            \n"
                    "pcmpeqb    %%xmm6, %%xmm0            \n"
                    "movdqa     %%xmm0,   (%%edi)         \n"
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0");
                    tmp_w -= 16;
                    tmp_src += 16;
                    tmp_dst += 16;
                }
 
                if( tmp_w >= 8 )
                {
                    __asm__ __volatile__ (
                    "movq       (%0),   %%xmm0            \n"
                    "pcmpeqb    %%xmm6, %%xmm0            \n"
                    "movq       %%xmm0,   (%%edi)         \n"
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0");
                    tmp_w -= 8;
                    tmp_src += 8;
                    tmp_dst += 8;
                }
                if( tmp_w >= 4 )
                {
                    __asm__ __volatile__ (
                    "movd       (%0),   %%xmm0            \n"
                    "pcmpeqb    %%xmm6, %%xmm0            \n"
                    "movd       %%xmm0,   (%%edi)         \n"
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0");
                    tmp_w -= 4;
                    tmp_src += 4;
                    tmp_dst += 4;
                }
                while(tmp_w--)
                    *tmp_dst++ = (*tmp_src++ == (u8)slot) ? 0xFF:0x00;
            };
        };
        safe_sti(ifl);
 
        ret = i915_gem_object_set_to_gtt_domain(to_intel_bo(obj), false);
    }
 
err2:
    mutex_unlock(&dev->struct_mutex);
err1:
    drm_gem_object_unreference(obj);
 
    return ret;
}
 
int i915_mask_update_ex(struct drm_device *dev, void *data,
            struct drm_file *file)
{
    struct drm_i915_mask_update *mask = data;
    struct drm_gem_object *obj;
    static unsigned int mask_seqno[256];
    static warn_count;
 
    rect_t win;
    u32    winw,winh;
    u32    ml,mt,mr,mb;
    u32    slot;
    int    ret = 0;
    slot = *((u8*)CURRENT_TASK);
 
    if( mask->forced == 0 && mask_seqno[slot] == os_display->mask_seqno)
        return 0;
 
    if(mask->forced)
        memset((void*)mask->bo_map,0,mask->width * mask->height);
 
    GetWindowRect(&win);
    win.right+= 1;
    win.bottom+=  1;
 
    winw = win.right - win.left;
    winh = win.bottom - win.top;
 
    if(mask->dx >= winw ||
       mask->dy >= winh)
       return 1;
 
    ml = win.left + mask->dx;
    mt = win.top  + mask->dy;
    mr = ml + mask->width;
    mb = mt + mask->height;
 
    if( ml >= win.right || mt >= win.bottom ||
        mr < win.left   || mb < win.top )
        return 1;
 
    if( mr > win.right )
        mr = win.right;
 
    if( mb > win.bottom )
        mb = win.bottom;
 
    mask->width  = mr - ml;
    mask->height = mb - mt;
 
    if( mask->width == 0 ||
        mask->height== 0 )
        return 1;
 
    obj = drm_gem_object_lookup(dev, file, mask->handle);
    if (obj == NULL)
        return -ENOENT;
 
    if (!obj->filp) {
        drm_gem_object_unreference_unlocked(obj);
        return -EINVAL;
    }
 
#if 0
    if(warn_count < 100)
    {
        printf("left %d top %d right %d bottom %d\n",
                ml, mt, mr, mb);
        warn_count++;
    };
#endif
 
 
#if 1
 
    {
        u8* src_offset;
        u8* dst_offset;
        u32 ifl;
 
        ret = i915_mutex_lock_interruptible(dev);
        if (ret)
            goto err1;
 
        i915_gem_object_set_to_cpu_domain(to_intel_bo(obj), true);
 
        src_offset = os_display->win_map;
        src_offset+= mt*os_display->width + ml;
        dst_offset = (u8*)mask->bo_map;
 
        u32 tmp_h = mask->height;
 
        ifl = safe_cli();
        {
            mask_seqno[slot] = os_display->mask_seqno;
 
            slot|= (slot<<8)|(slot<<16)|(slot<<24);
 
            __asm__ __volatile__ (
            "movd       %[slot],   %%xmm6         \n"
            "punpckldq  %%xmm6, %%xmm6            \n"
            "punpcklqdq %%xmm6, %%xmm6            \n"
            :: [slot]  "m" (slot)
            :"xmm6");
 
            while( tmp_h--)
            {
                int tmp_w = mask->width;
 
                u8* tmp_src = src_offset;
                u8* tmp_dst = dst_offset;
 
                src_offset+= os_display->width;
                dst_offset+= mask->bo_pitch;
 
                while(tmp_w >= 64)
                {
                    __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"
 
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0","xmm1","xmm2","xmm3");
                    tmp_w -= 64;
                    tmp_src += 64;
                    tmp_dst += 64;
                }
 
                if( tmp_w >= 32 )
                {
                    __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"
 
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0","xmm1");
                    tmp_w -= 32;
                    tmp_src += 32;
                    tmp_dst += 32;
                }
 
                if( tmp_w >= 16 )
                {
                    __asm__ __volatile__ (
                    "movdqu     (%0),   %%xmm0            \n"
                    "pcmpeqb    %%xmm6, %%xmm0            \n"
                    "movdqa     %%xmm0,   (%%edi)         \n"
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0");
                    tmp_w -= 16;
                    tmp_src += 16;
                    tmp_dst += 16;
                }
 
                if( tmp_w >= 8 )
                {
                    __asm__ __volatile__ (
                    "movq       (%0),   %%xmm0            \n"
                    "pcmpeqb    %%xmm6, %%xmm0            \n"
                    "movq       %%xmm0,   (%%edi)         \n"
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0");
                    tmp_w -= 8;
                    tmp_src += 8;
                    tmp_dst += 8;
                }
                if( tmp_w >= 4 )
                {
                    __asm__ __volatile__ (
                    "movd       (%0),   %%xmm0            \n"
                    "pcmpeqb    %%xmm6, %%xmm0            \n"
                    "movd       %%xmm0,   (%%edi)         \n"
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0");
                    tmp_w -= 4;
                    tmp_src += 4;
                    tmp_dst += 4;
                }
                while(tmp_w--)
                    *tmp_dst++ = (*tmp_src++ == (u8)slot) ? 0xFF:0x00;
            };
        };
        safe_sti(ifl);
 
        i915_gem_object_set_to_gtt_domain(to_intel_bo(obj), false);
    }
#endif
 
err2:
    mutex_unlock(&dev->struct_mutex);
err1:
    drm_gem_object_unreference(obj);
 
    return ret;
}
 
 
 
 
#define NSEC_PER_SEC    1000000000L
 
void getrawmonotonic(struct timespec *ts)
{
    u32 tmp = GetTimerTicks();
 
    ts->tv_sec  = tmp/100;
    ts->tv_nsec = (tmp - ts->tv_sec*100)*10000000;
}
 
void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)
{
    unsigned long flags;
 
//    wait->flags &= ~WQ_FLAG_EXCLUSIVE;
    spin_lock_irqsave(&q->lock, flags);
    if (list_empty(&wait->task_list))
            __add_wait_queue(q, wait);
    spin_unlock_irqrestore(&q->lock, flags);
}
 
/**
 * finish_wait - clean up after waiting in a queue
 * @q: waitqueue waited on
 * @wait: wait descriptor
 *
 * Sets current thread back to running state and removes
 * the wait descriptor from the given waitqueue if still
 * queued.
 */
void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
{
    unsigned long flags;
 
//    __set_current_state(TASK_RUNNING);
    /*
     * We can check for list emptiness outside the lock
     * IFF:
     *  - we use the "careful" check that verifies both
     *    the next and prev pointers, so that there cannot
     *    be any half-pending updates in progress on other
     *    CPU's that we haven't seen yet (and that might
     *    still change the stack area.
     * and
     *  - all other users take the lock (ie we can only
     *    have _one_ other CPU that looks at or modifies
     *    the list).
     */
    if (!list_empty_careful(&wait->task_list)) {
            spin_lock_irqsave(&q->lock, flags);
            list_del_init(&wait->task_list);
            spin_unlock_irqrestore(&q->lock, flags);
    }
 
    DestroyEvent(wait->evnt);
}
 
int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
{
    list_del_init(&wait->task_list);
    return 1;
}
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>

Rev 6088	Rev 6103
1	#define iowrite32(v, addr) writel((v), (addr))	1	#define iowrite32(v, addr) writel((v), (addr))
2		2
3	#include	3	#include
4	#include	4	#include
5	#include "i915_drv.h"	5	#include "i915_drv.h"
6	#include "intel_drv.h"	6	#include "intel_drv.h"
7	#include	7	#include
8	#include	8	#include
9	#include	9	#include
10		10
11	#include	11	#include
12		12
13	#include "bitmap.h"	13	#include "bitmap.h"
14	#include	14	#include
15		15
16		16
17	display_t *os_display;	17	display_t *os_display;
18	struct drm_i915_gem_object *main_fb_obj;	18	struct drm_i915_gem_object *main_fb_obj;
19	struct drm_framebuffer *main_framebuffer;	19	struct drm_framebuffer *main_framebuffer;
20		20
21	u32 cmd_buffer;	21	u32 cmd_buffer;
22	u32 cmd_offset;	22	u32 cmd_offset;
23		23
24	void init_render();	24	void init_render();
25	int sna_init();	25	int sna_init();
26		26
27	static cursor_t* __stdcall select_cursor_kms(cursor_t *cursor);	27	static cursor_t* __stdcall select_cursor_kms(cursor_t *cursor);
28	static void __stdcall move_cursor_kms(cursor_t *cursor, int x, int y);	28	static void __stdcall move_cursor_kms(cursor_t *cursor, int x, int y);
29		29
30	void __stdcall restore_cursor(int x, int y)	30	void __stdcall restore_cursor(int x, int y)
31	{};	31	{};
32		32
33	void disable_mouse(void)	33	void disable_mouse(void)
34	{};	34	{};
35		35
36	struct mutex cursor_lock;	36	struct mutex cursor_lock;
37		37
38	static char manufacturer_name(unsigned char x)	38	static char manufacturer_name(unsigned char x)
39	{	39	{
40	static char name[4];	40	static char name[4];
41		41
42	name[0] = ((x[0] & 0x7C) >> 2) + '@';	42	name[0] = ((x[0] & 0x7C) >> 2) + '@';
43	name[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@';	43	name[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@';
44	name[2] = (x[1] & 0x1F) + '@';	44	name[2] = (x[1] & 0x1F) + '@';
45	name[3] = 0;	45	name[3] = 0;
46		46
47	return name;	47	return name;
48	}	48	}
49		49
50	static int count_connector_modes(struct drm_connector* connector)	50	static int count_connector_modes(struct drm_connector* connector)
51	{	51	{
52	struct drm_display_mode *mode;	52	struct drm_display_mode *mode;
53	int count = 0;	53	int count = 0;
54		54
55	list_for_each_entry(mode, &connector->modes, head)	55	list_for_each_entry(mode, &connector->modes, head)
56	count++;	56	count++;
57		57
58	return count;	58	return count;
59	};	59	};
60		60
61	static int set_mode(struct drm_device dev, struct drm_connector connector,	61	static int set_mode(struct drm_device dev, struct drm_connector connector,
62	struct drm_crtc crtc, videomode_t reqmode, bool strict)	62	struct drm_crtc crtc, videomode_t reqmode, bool strict)
63	{	63	{
64	struct drm_i915_private *dev_priv = dev->dev_private;	64	struct drm_i915_private *dev_priv = dev->dev_private;
65		65
66	struct drm_mode_config *config = &dev->mode_config;	66	struct drm_mode_config *config = &dev->mode_config;
67	struct drm_display_mode mode = NULL, tmpmode;	67	struct drm_display_mode mode = NULL, tmpmode;
68	struct drm_connector *tmpc;	68	struct drm_connector *tmpc;
69	struct drm_framebuffer *fb = NULL;	69	struct drm_framebuffer *fb = NULL;
70	struct drm_mode_set set;	70	struct drm_mode_set set;
71	const char *con_name;	71	const char *con_name;
72	unsigned hdisplay, vdisplay;	72	unsigned hdisplay, vdisplay;
73	int stride;	73	int stride;
74	int ret;	74	int ret;
75		75
76	ENTER();	-
77		-
78	drm_modeset_lock_all(dev);	76	drm_modeset_lock_all(dev);
79		77
80	list_for_each_entry(tmpc, &dev->mode_config.connector_list, head)	78	list_for_each_entry(tmpc, &dev->mode_config.connector_list, head)
81	{	79	{
82	const struct drm_connector_funcs *f = tmpc->funcs;	80	const struct drm_connector_funcs *f = tmpc->funcs;
83	if(tmpc == connector)	81	if(tmpc == connector)
84	continue;	82	continue;
85	f->dpms(tmpc, DRM_MODE_DPMS_OFF);	83	f->dpms(tmpc, DRM_MODE_DPMS_OFF);
86	};	84	};
87		85
88	list_for_each_entry(tmpmode, &connector->modes, head)	86	list_for_each_entry(tmpmode, &connector->modes, head)
89	{	87	{
90	if( (tmpmode->hdisplay == reqmode->width) &&	88	if( (tmpmode->hdisplay == reqmode->width) &&
91	(tmpmode->vdisplay == reqmode->height) &&	89	(tmpmode->vdisplay == reqmode->height) &&
92	(drm_mode_vrefresh(tmpmode) == reqmode->freq) )	90	(drm_mode_vrefresh(tmpmode) == reqmode->freq) )
93	{	91	{
94	mode = tmpmode;	92	mode = tmpmode;
95	goto do_set;	93	goto do_set;
96	}	94	}
97	};	95	};
98		96
99	if( (mode == NULL) && (strict == false) )	97	if( (mode == NULL) && (strict == false) )
100	{	98	{
101	list_for_each_entry(tmpmode, &connector->modes, head)	99	list_for_each_entry(tmpmode, &connector->modes, head)
102	{	100	{
103	if( (tmpmode->hdisplay == reqmode->width) &&	101	if( (tmpmode->hdisplay == reqmode->width) &&
104	(tmpmode->vdisplay == reqmode->height) )	102	(tmpmode->vdisplay == reqmode->height) )
105	{	103	{
106	mode = tmpmode;	104	mode = tmpmode;
107	goto do_set;	105	goto do_set;
108	}	106	}
109	};	107	};
110	};	108	};
111		109
112	DRM_ERROR("%s failed\n", __FUNCTION__);	110	DRM_ERROR("%s failed\n", __FUNCTION__);
113		111
114	return -1;	112	return -1;
115		113
116	do_set:	114	do_set:
117		115
118		116
119	con_name = connector->name;	117	con_name = connector->name;
120		118
121	char con_edid[128];	119	char con_edid[128];
122		120
123	memcpy(con_edid, connector->edid_blob_ptr->data, 128);	121	memcpy(con_edid, connector->edid_blob_ptr->data, 128);
124	DRM_DEBUG_KMS("Manufacturer: %s Model %x Serial Number %u\n",	122	DRM_DEBUG_KMS("Manufacturer: %s Model %x Serial Number %u\n",
125	manufacturer_name(con_edid + 0x08),	123	manufacturer_name(con_edid + 0x08),
126	(unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),	124	(unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),
127	(unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)	125	(unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)
128	+ (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));	126	+ (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));
129		127
130	DRM_DEBUG_KMS("set mode %d %d: crtc %d connector %s\n",	128	DRM_DEBUG_KMS("set mode %d %d: crtc %d connector %s\n",
131	reqmode->width, reqmode->height, crtc->base.id,	129	reqmode->width, reqmode->height, crtc->base.id,
132	con_name);	130	con_name);
133		131
134	drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);	132	drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
135		133
136	hdisplay = mode->hdisplay;	134	hdisplay = mode->hdisplay;
137	vdisplay = mode->vdisplay;	135	vdisplay = mode->vdisplay;
138		136
139	// if (crtc->invert_dimensions)	137	// if (crtc->invert_dimensions)
140	// swap(hdisplay, vdisplay);	138	// swap(hdisplay, vdisplay);
141		139
142	fb = crtc->primary->fb;	140	fb = crtc->primary->fb;
143	if(fb == NULL)	141	if(fb == NULL)
144	fb = main_framebuffer;	142	fb = main_framebuffer;
145		143
146	fb->width = reqmode->width;	144	fb->width = reqmode->width;
147	fb->height = reqmode->height;	145	fb->height = reqmode->height;
148		146
149	main_fb_obj->tiling_mode = I915_TILING_X;	147	main_fb_obj->tiling_mode = I915_TILING_X;
150		148
151	if( main_fb_obj->tiling_mode == I915_TILING_X)	149	if( main_fb_obj->tiling_mode == I915_TILING_X)
152	{	150	{
153	if(IS_GEN3(dev))	151	if(IS_GEN3(dev))
154	for (stride = 512; stride < reqmode->width * 4; stride <<= 1);	152	for (stride = 512; stride < reqmode->width * 4; stride <<= 1);
155	else	153	else
156	stride = ALIGN(reqmode->width * 4, 512);	154	stride = ALIGN(reqmode->width * 4, 512);
157	}	155	}
158	else	156	else
159	{	157	{
160	stride = ALIGN(reqmode->width * 4, 64);	158	stride = ALIGN(reqmode->width * 4, 64);
161	}	159	}
162		160
163	fb->pitches[0] =	161	fb->pitches[0] =
164	fb->pitches[1] =	162	fb->pitches[1] =
165	fb->pitches[2] =	163	fb->pitches[2] =
166	fb->pitches[3] = stride;	164	fb->pitches[3] = stride;
167		165
168	main_fb_obj->stride = stride;	166	main_fb_obj->stride = stride;
169		167
170	fb->bits_per_pixel = 32;	168	fb->bits_per_pixel = 32;
171	fb->depth = 24;	169	fb->depth = 24;
172		170
173	crtc->enabled = true;	171	crtc->enabled = true;
174	os_display->crtc = crtc;	172	os_display->crtc = crtc;
175		173
176	i915_gem_object_put_fence(main_fb_obj);	174	i915_gem_object_put_fence(main_fb_obj);
177		175
178	printf("fb:%p %dx%dx pitch %d format %x\n",	176	printf("fb:%p %dx%dx pitch %d format %x\n",
179	fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format);	177	fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format);
180		178
181	set.crtc = crtc;	179	set.crtc = crtc;
182	set.x = 0;	180	set.x = 0;
183	set.y = 0;	181	set.y = 0;
184	set.mode = mode;	182	set.mode = mode;
185	set.connectors = &connector;	183	set.connectors = &connector;
186	set.num_connectors = 1;	184	set.num_connectors = 1;
187	set.fb = fb;	185	set.fb = fb;
188		186
189	ret = drm_mode_set_config_internal(&set);	187	ret = drm_mode_set_config_internal(&set);
190		188
191	if ( !ret )	189	if ( !ret )
192	{	190	{
193	os_display->width = fb->width;	191	os_display->width = fb->width;
194	os_display->height = fb->height;	192	os_display->height = fb->height;
195	os_display->vrefresh = drm_mode_vrefresh(mode);	193	os_display->vrefresh = drm_mode_vrefresh(mode);
196		194
197	sysSetScreen(fb->width, fb->height, fb->pitches[0]);	195	sysSetScreen(fb->width, fb->height, fb->pitches[0]);
198		196
199	DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",	197	DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",
200	fb->width, fb->height, fb->pitches[0]);	198	fb->width, fb->height, fb->pitches[0]);
201	}	199	}
202	else	200	else
203	DRM_ERROR("failed to set mode %d_%d on crtc %p\n",	201	DRM_ERROR("failed to set mode %d_%d on crtc %p\n",
204	fb->width, fb->height, crtc);	202	fb->width, fb->height, crtc);
205		203
206	drm_modeset_unlock_all(dev);	204	drm_modeset_unlock_all(dev);
207		205
208	LEAVE();	-
209		-
210	return ret;	206	return ret;
211	}	207	}
212		208
213	static int set_mode_ex(struct drm_device *dev,	209	static int set_mode_ex(struct drm_device *dev,
214	struct drm_connector connector, struct drm_display_mode mode)	210	struct drm_connector connector, struct drm_display_mode mode)
215	{	211	{
216	struct drm_i915_private *dev_priv = dev->dev_private;	212	struct drm_i915_private *dev_priv = dev->dev_private;
217	struct drm_connector *tmpc;	213	struct drm_connector *tmpc;
218	struct drm_mode_config *config = &dev->mode_config;	214	struct drm_mode_config *config = &dev->mode_config;
219	struct drm_framebuffer *fb = NULL;	215	struct drm_framebuffer *fb = NULL;
220	struct drm_mode_set set;	216	struct drm_mode_set set;
221	char con_edid[128];	217	char con_edid[128];
222	int stride;	218	int stride;
223	int ret;	219	int ret;
224		220
225	ENTER();	-
226		-
227	drm_modeset_lock_all(dev);	221	drm_modeset_lock_all(dev);
228		222
229	list_for_each_entry(tmpc, &dev->mode_config.connector_list, head)	223	list_for_each_entry(tmpc, &dev->mode_config.connector_list, head)
230	{	224	{
231	const struct drm_connector_funcs *f = tmpc->funcs;	225	const struct drm_connector_funcs *f = tmpc->funcs;
232	if(tmpc == connector)	226	if(tmpc == connector)
233	continue;	227	continue;
234	f->dpms(tmpc, DRM_MODE_DPMS_OFF);	228	f->dpms(tmpc, DRM_MODE_DPMS_OFF);
235	};	229	};
236		230
237	drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);	231	drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
238		232
239	fb = connector->encoder->crtc->primary->fb;	233	fb = connector->encoder->crtc->primary->fb;
240	if(fb == NULL)	234	if(fb == NULL)
241	fb = main_framebuffer;	235	fb = main_framebuffer;
242		236
243	fb->width = mode->hdisplay;	237	fb->width = mode->hdisplay;
244	fb->height = mode->vdisplay;;	238	fb->height = mode->vdisplay;;
245		239
246	main_fb_obj->tiling_mode = I915_TILING_X;	240	main_fb_obj->tiling_mode = I915_TILING_X;
247		241
248	if( main_fb_obj->tiling_mode == I915_TILING_X)	242	if( main_fb_obj->tiling_mode == I915_TILING_X)
249	{	243	{
250	if(IS_GEN3(dev))	244	if(IS_GEN3(dev))
251	for (stride = 512; stride < mode->hdisplay * 4; stride <<= 1);	245	for (stride = 512; stride < mode->hdisplay * 4; stride <<= 1);
252	else	246	else
253	stride = ALIGN(mode->hdisplay * 4, 512);	247	stride = ALIGN(mode->hdisplay * 4, 512);
254	}	248	}
255	else	249	else
256	{	250	{
257	stride = ALIGN(mode->hdisplay * 4, 64);	251	stride = ALIGN(mode->hdisplay * 4, 64);
258	}	252	}
259		253
260	fb->pitches[0] =	254	fb->pitches[0] =
261	fb->pitches[1] =	255	fb->pitches[1] =
262	fb->pitches[2] =	256	fb->pitches[2] =
263	fb->pitches[3] = stride;	257	fb->pitches[3] = stride;
264		258
265	main_fb_obj->stride = stride;	259	main_fb_obj->stride = stride;
266		260
267	fb->bits_per_pixel = 32;	261	fb->bits_per_pixel = 32;
268	fb->depth = 24;	262	fb->depth = 24;
269		263
270	connector->encoder->crtc->enabled = true;	264	connector->encoder->crtc->enabled = true;
271		265
272	i915_gem_object_put_fence(main_fb_obj);	266	i915_gem_object_put_fence(main_fb_obj);
273		267
274	memcpy(con_edid, connector->edid_blob_ptr->data, 128);	268	memcpy(con_edid, connector->edid_blob_ptr->data, 128);
275	DRM_DEBUG_KMS("set mode %dx%d: crtc %d connector %s\n"	269	DRM_DEBUG_KMS("set mode %dx%d: crtc %d connector %s\n"
276	"monitor: %s model %x serial number %u\n",	270	"monitor: %s model %x serial number %u\n",
277	fb->width, fb->height,	271	fb->width, fb->height,
278	connector->encoder->crtc->base.id, connector->name,	272	connector->encoder->crtc->base.id, connector->name,
279	manufacturer_name(con_edid + 0x08),	273	manufacturer_name(con_edid + 0x08),
280	(unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),	274	(unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),
281	(unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)	275	(unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)
282	+ (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));	276	+ (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));
283		277
284	DRM_DEBUG_KMS("use framebuffer %p %dx%d pitch %d format %x\n",	278	DRM_DEBUG_KMS("use framebuffer %p %dx%d pitch %d format %x\n",
285	fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format);	279	fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format);
286		280
287	set.crtc = connector->encoder->crtc;	281	set.crtc = connector->encoder->crtc;
288	set.x = 0;	282	set.x = 0;
289	set.y = 0;	283	set.y = 0;
290	set.mode = mode;	284	set.mode = mode;
291	set.connectors = &connector;	285	set.connectors = &connector;
292	set.num_connectors = 1;	286	set.num_connectors = 1;
293	set.fb = fb;	287	set.fb = fb;
294		288
295	ret = drm_mode_set_config_internal(&set);	289	ret = drm_mode_set_config_internal(&set);
296	if ( !ret )	290	if ( !ret )
297	{	291	{
298	struct drm_crtc *crtc = os_display->crtc;	292	struct drm_crtc *crtc = os_display->crtc;
299		293
300	os_display->width = fb->width;	294	os_display->width = fb->width;
301	os_display->height = fb->height;	295	os_display->height = fb->height;
302	os_display->vrefresh = drm_mode_vrefresh(mode);	296	os_display->vrefresh = drm_mode_vrefresh(mode);
303		297
304	sysSetScreen(fb->width, fb->height, fb->pitches[0]);	298	sysSetScreen(fb->width, fb->height, fb->pitches[0]);
305		299
306	os_display->connector = connector;	300	os_display->connector = connector;
307	os_display->crtc = connector->encoder->crtc;	301	os_display->crtc = connector->encoder->crtc;
308	os_display->supported_modes = count_connector_modes(connector);	302	os_display->supported_modes = count_connector_modes(connector);
309		303
310	crtc->cursor_x = os_display->width/2;	304	crtc->cursor_x = os_display->width/2;
311	crtc->cursor_y = os_display->height/2;	305	crtc->cursor_y = os_display->height/2;
312		306
313	select_cursor_kms(os_display->cursor);	307	select_cursor_kms(os_display->cursor);
314		308
315	DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",	309	DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",
316	fb->width, fb->height, fb->pitches[0]);	310	fb->width, fb->height, fb->pitches[0]);
317	}	311	}
318	else	312	else
319	DRM_ERROR(" failed to set mode %d_%d on crtc %p\n",	313	DRM_ERROR(" failed to set mode %d_%d on crtc %p\n",
320	fb->width, fb->height, connector->encoder->crtc);	314	fb->width, fb->height, connector->encoder->crtc);
321		315
322	drm_modeset_unlock_all(dev);	316	drm_modeset_unlock_all(dev);
323		317
324	LEAVE();	-
325		-
326	return ret;	318	return ret;
327	}	319	}
328		320
329	static int set_cmdline_mode(struct drm_device dev, struct drm_connector connector)	321	static int set_cmdline_mode(struct drm_device dev, struct drm_connector connector)
330	{	322	{
331	struct drm_display_mode *mode;	323	struct drm_display_mode *mode;
332	int retval;	324	int retval;
333		325
334	mode = drm_mode_create_from_cmdline_mode(dev, &connector->cmdline_mode);	326	mode = drm_mode_create_from_cmdline_mode(dev, &connector->cmdline_mode);
335	if(mode == NULL)	327	if(mode == NULL)
336	return EINVAL;	328	return EINVAL;
337		329
338	retval = set_mode_ex(dev, connector, mode);	330	retval = set_mode_ex(dev, connector, mode);
339		331
340	drm_mode_destroy(dev, mode);	332	drm_mode_destroy(dev, mode);
341	return retval;	333	return retval;
342	};	334	};
343		335
344	static struct drm_crtc get_possible_crtc(struct drm_device dev, struct drm_encoder *encoder)	336	static struct drm_crtc get_possible_crtc(struct drm_device dev, struct drm_encoder *encoder)
345	{	337	{
346	struct drm_crtc *tmp_crtc;	338	struct drm_crtc *tmp_crtc;
347	int crtc_mask = 1;	339	int crtc_mask = 1;
348		340
349	list_for_each_entry(tmp_crtc, &dev->mode_config.crtc_list, head)	341	list_for_each_entry(tmp_crtc, &dev->mode_config.crtc_list, head)
350	{	342	{
351	if (encoder->possible_crtcs & crtc_mask)	343	if (encoder->possible_crtcs & crtc_mask)
352	{	344	{
353	encoder->crtc = tmp_crtc;	345	encoder->crtc = tmp_crtc;
354	DRM_DEBUG_KMS("use CRTC %p ID %d\n", tmp_crtc, tmp_crtc->base.id);	346	DRM_DEBUG_KMS("use CRTC %p ID %d\n", tmp_crtc, tmp_crtc->base.id);
355	return tmp_crtc;	347	return tmp_crtc;
356	};	348	};
357	crtc_mask <<= 1;	349	crtc_mask <<= 1;
358	};	350	};
359	return NULL;	351	return NULL;
360	};	352	};
361		353
362	static int check_connector(struct drm_device dev, struct drm_connector connector)	354	static int check_connector(struct drm_device dev, struct drm_connector connector)
363	{	355	{
364	const struct drm_connector_helper_funcs *connector_funcs;	356	const struct drm_connector_helper_funcs *connector_funcs;
365	struct drm_encoder *encoder;	357	struct drm_encoder *encoder;
366	struct drm_crtc *crtc;	358	struct drm_crtc *crtc;
367		359
368	if( connector->status != connector_status_connected)	360	if( connector->status != connector_status_connected)
369	return -EINVAL;	361	return -EINVAL;
370		362
371	encoder = connector->encoder;	363	encoder = connector->encoder;
372		364
373	if(encoder == NULL)	365	if(encoder == NULL)
374	{	366	{
375	connector_funcs = connector->helper_private;	367	connector_funcs = connector->helper_private;
376	encoder = connector_funcs->best_encoder(connector);	368	encoder = connector_funcs->best_encoder(connector);
377		369
378	if( encoder == NULL)	370	if( encoder == NULL)
379	{	371	{
380	DRM_DEBUG_KMS("CONNECTOR %s ID: %d no active encoders\n",	372	DRM_DEBUG_KMS("CONNECTOR %s ID: %d no active encoders\n",
381	connector->name, connector->base.id);	373	connector->name, connector->base.id);
382	return -EINVAL;	374	return -EINVAL;
383	};	375	};
384	}	376	}
385		377
386	crtc = encoder->crtc;	378	crtc = encoder->crtc;
387	if(crtc == NULL)	379	if(crtc == NULL)
388	crtc = get_possible_crtc(dev, encoder);	380	crtc = get_possible_crtc(dev, encoder);
389		381
390	if(crtc != NULL)	382	if(crtc != NULL)
391	{	383	{
392	encoder->crtc = crtc;	384	encoder->crtc = crtc;
393	return 0;	385	return 0;
394	}	386	}
395	else	387	else
396	DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id);	388	DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id);
397	return -EINVAL;	389	return -EINVAL;
398	}	390	}
399		391
400	static struct drm_connector* get_cmdline_connector(struct drm_device dev, const char cmdline)	392	static struct drm_connector* get_cmdline_connector(struct drm_device dev, const char cmdline)
401	{	393	{
402	struct drm_connector *connector;	394	struct drm_connector *connector;
403		395
404	list_for_each_entry(connector, &dev->mode_config.connector_list, head)	396	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
405	{	397	{
406	int name_len = __builtin_strlen(connector->name);	398	int name_len = __builtin_strlen(connector->name);
407		399
408	if (name_len == 0)	400	if (name_len == 0)
409	continue;	401	continue;
410		402
411	if (__builtin_strncmp(connector->name, cmdline, name_len))	403	if (__builtin_strncmp(connector->name, cmdline, name_len))
412	continue;	404	continue;
413		405
414	if(check_connector(dev, connector) == 0)	406	if(check_connector(dev, connector) == 0)
415	return connector;	407	return connector;
416	}	408	}
417	return NULL;	409	return NULL;
418	}	410	}
419		411
420		412
421	static int choose_config(struct drm_device dev, struct drm_connector *boot_connector,	413	static int choose_config(struct drm_device dev, struct drm_connector *boot_connector,
422	struct drm_crtc **boot_crtc)	414	struct drm_crtc **boot_crtc)
423	{	415	{
424	const struct drm_connector_helper_funcs *connector_funcs;	416	struct drm_connector *connector;
425	struct drm_connector *connector = NULL;	-
426	struct drm_encoder *encoder = NULL;	417
427	struct drm_crtc *crtc = NULL;	-
428		-
429	if((i915.cmdline_mode != NULL) && (*i915.cmdline_mode != 0))	418	if((i915.cmdline_mode != NULL) && (*i915.cmdline_mode != 0))
430	{	419	{
431	connector = get_cmdline_connector(dev, i915.cmdline_mode);	420	connector = get_cmdline_connector(dev, i915.cmdline_mode);
432	if(connector != NULL)	421	if(connector != NULL)
433	{	422	{
434	*boot_connector = connector;	423	*boot_connector = connector;
435	*boot_crtc = connector->encoder->crtc;	424	*boot_crtc = connector->encoder->crtc;
436	return 0;	425	return 0;
437	}	426	}
438	}	427	}
439		428
440	list_for_each_entry(connector, &dev->mode_config.connector_list, head)	429	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
441	{	430	{
442	if(check_connector(dev, connector) == 0)	431	if(check_connector(dev, connector) == 0)
443	{	432	{
444	*boot_connector = connector;	433	*boot_connector = connector;
445	*boot_crtc = connector->encoder->crtc;	434	*boot_crtc = connector->encoder->crtc;
446	return 0;	435	return 0;
447	};	436	};
448	};	437	};
449		438
450	return -ENOENT;	439	return -ENOENT;
451	};	440	};
452		441
-		442
453	static int get_boot_mode(struct drm_connector connector, videomode_t usermode)	443	static int get_boot_mode(struct drm_connector connector, videomode_t usermode)
454	{	444	{
455	struct drm_display_mode *mode;	445	struct drm_display_mode *mode;
456		446
457	list_for_each_entry(mode, &connector->modes, head)	447	list_for_each_entry(mode, &connector->modes, head)
458	{	448	{
459	if( os_display->width == mode->hdisplay &&	449	if( os_display->width == mode->hdisplay &&
460	os_display->height == mode->vdisplay &&	450	os_display->height == mode->vdisplay &&
461	drm_mode_vrefresh(mode) == 60)	451	drm_mode_vrefresh(mode) == 60)
462	{	452	{
463	usermode->width = os_display->width;	453	usermode->width = os_display->width;
464	usermode->height = os_display->height;	454	usermode->height = os_display->height;
465	usermode->freq = 60;	455	usermode->freq = 60;
466	return 1;	456	return 1;
467	}	457	}
468	}	458	}
469	return 0;	459	return 0;
470	}	460	}
471		461
472	int init_display_kms(struct drm_device dev, videomode_t usermode)	462	int init_display_kms(struct drm_device dev, videomode_t usermode)
473	{	463	{
474	struct drm_connector_helper_funcs *connector_funcs;	464	struct drm_connector_helper_funcs *connector_funcs;
475	struct drm_connector *connector = NULL;	465	struct drm_connector *connector = NULL;
476	struct drm_crtc *crtc = NULL;	466	struct drm_crtc *crtc = NULL;
477	struct drm_framebuffer *fb;	467	struct drm_framebuffer *fb;
478		468
479	cursor_t *cursor;	469	cursor_t *cursor;
480	u32 ifl;	470	u32 ifl;
481	int ret;	471	int ret;
482		472
483	ENTER();	-
484		-
485	mutex_lock(&dev->mode_config.mutex);	473	mutex_lock(&dev->mode_config.mutex);
486	ret = choose_config(dev, &connector, &crtc);	474	ret = choose_config(dev, &connector, &crtc);
487	if(ret)	475	if(ret)
488	{	476	{
489	mutex_unlock(&dev->mode_config.mutex);	477	mutex_unlock(&dev->mode_config.mutex);
490	DRM_DEBUG_KMS("No active connectors!\n");	478	DRM_DEBUG_KMS("No active connectors!\n");
491	return -1;	479	return -1;
492	};	480	};
493		481
494	mutex_lock(&dev->object_name_lock);	482	mutex_lock(&dev->object_name_lock);
495	idr_preload(GFP_KERNEL);	483	idr_preload(GFP_KERNEL);
496		484
497	if (!main_fb_obj->base.name) {	485	if (!main_fb_obj->base.name) {
498	ret = idr_alloc(&dev->object_name_idr, &main_fb_obj->base, 1, 0, GFP_NOWAIT);	486	ret = idr_alloc(&dev->object_name_idr, &main_fb_obj->base, 1, 0, GFP_NOWAIT);
499		487

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/kms_display.c – Rev 6088 → 6103