Subversion Repositories Kolibri OS

#include 

#include 

#include "radeon_drm.h"

#include "radeon.h"

#include "radeon_object.h"

#include "display.h"

#include "drm_fb_helper.h"

    struct drm_fb_helper        helper;

    struct radeon_framebuffer   rfb;

    struct list_head fbdev_list;

    struct radeon_device        *rdev;

};

static void       __stdcall move_cursor_kms(cursor_t *cursor, int x, int y);

{

    struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);

    struct radeon_device *rdev = crtc->dev->dev_private;

        WREG32(RADEON_MM_INDEX, AVIVO_D1CUR_CONTROL + radeon_crtc->crtc_offset);

        WREG32(RADEON_MM_DATA, AVIVO_D1CURSOR_EN |

                 (AVIVO_D1CURSOR_MODE_24BPP << AVIVO_D1CURSOR_MODE_SHIFT));

    } else {

        switch (radeon_crtc->crtc_id) {

        case 0:

            WREG32(RADEON_MM_INDEX, RADEON_CRTC_GEN_CNTL);

            break;

        case 1:

            WREG32(RADEON_MM_INDEX, RADEON_CRTC2_GEN_CNTL);

            break;

        default:

            return;

        }

                      (RADEON_CRTC_CUR_MODE_24BPP << RADEON_CRTC_CUR_MODE_SHIFT)),

             ~(RADEON_CRTC_CUR_EN | RADEON_CRTC_CUR_MODE_MASK));

    }

}

{

    struct radeon_device *rdev = crtc->dev->dev_private;

    struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);

    uint32_t cur_lock;

        cur_lock = RREG32(AVIVO_D1CUR_UPDATE + radeon_crtc->crtc_offset);

        if (lock)

            cur_lock |= AVIVO_D1CURSOR_UPDATE_LOCK;

        else

            cur_lock &= ~AVIVO_D1CURSOR_UPDATE_LOCK;

        WREG32(AVIVO_D1CUR_UPDATE + radeon_crtc->crtc_offset, cur_lock);

    } else {

        cur_lock = RREG32(RADEON_CUR_OFFSET + radeon_crtc->crtc_offset);

        if (lock)

            cur_lock |= RADEON_CUR_LOCK;

        else

            cur_lock &= ~RADEON_CUR_LOCK;

        WREG32(RADEON_CUR_OFFSET + radeon_crtc->crtc_offset, cur_lock);

    }

}

{

    struct radeon_device *rdev;

    struct radeon_crtc   *radeon_crtc;

    cursor_t *old;

    uint32_t  gpu_addr;

    radeon_crtc = to_radeon_crtc(rdisplay->crtc);

    gpu_addr = radeon_bo_gpu_offset(cursor->robj);

        WREG32(AVIVO_D1CUR_SURFACE_ADDRESS + radeon_crtc->crtc_offset, gpu_addr);

    else {

        radeon_crtc->legacy_cursor_offset = gpu_addr - rdev->mc.vram_start;

        /* offset is from DISP(2)_BASE_ADDRESS */

        WREG32(RADEON_CUR_OFFSET + radeon_crtc->crtc_offset, radeon_crtc->legacy_cursor_offset);

    }

};

{

    struct radeon_device *rdev;

    rdev = (struct radeon_device *)rdisplay->ddev->dev_private;

    struct drm_crtc *crtc = rdisplay->crtc;

    struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);

    int hot_y = cursor->hot_y;

    if (ASIC_IS_AVIVO(rdev))

    {

        int w = 32;

        int i = 0;

        struct drm_crtc *crtc_p;

//        x += crtc->x;

//        y += crtc->y;

#if 0

        /* avivo cursor image can't end on 128 pixel boundry or

         * go past the end of the frame if both crtcs are enabled

         */

        list_for_each_entry(crtc_p, &crtc->dev->mode_config.crtc_list, head) {

            if (crtc_p->enabled)

                i++;

        }

        if (i > 1) {

            int cursor_end, frame_end;

            frame_end = crtc->x + crtc->mode.crtc_hdisplay;

            if (cursor_end >= frame_end) {

                w = w - (cursor_end - frame_end);

                if (!(frame_end & 0x7f))

                    w--;

            } else {

                if (!(cursor_end & 0x7f))

                    w--;

            }

            if (w <= 0)

                w = 1;

        }

#endif

        WREG32(AVIVO_D1CUR_POSITION + radeon_crtc->crtc_offset,

               (x << 16) | y);

        WREG32(AVIVO_D1CUR_HOT_SPOT + radeon_crtc->crtc_offset,

               (hot_x << 16) | hot_y);

        WREG32(AVIVO_D1CUR_SIZE + radeon_crtc->crtc_offset,

               ((w - 1) << 16) | 31);

    } else {

        if (crtc->mode.flags & DRM_MODE_FLAG_DBLSCAN)

            y *= 2;

        int       xorg =0, yorg=0;

        y = y - hot_y;

        {

            xorg = -x + 1;

            x = 0;

        }

        {

            yorg = -hot_y + 1;

            y = 0;

        };

               (RADEON_CUR_LOCK | (xorg << 16) | yorg ));

        WREG32(RADEON_CUR_HORZ_VERT_POSN,

               (RADEON_CUR_LOCK | (x << 16) | y));

        WREG32(RADEON_CUR_OFFSET,

         (gpu_addr - rdev->mc.vram_start + (yorg * 256)));

    }

    radeon_lock_cursor_kms(crtc, false);

}

{

    static char name[4];

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

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

    name[3] = 0;

}

              videomode_t *reqmode, bool strict)

{

    struct drm_display_mode  *mode = NULL, *tmpmode;

               reqmode->width, reqmode->height, reqmode->freq);

    {

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

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

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

        {

            mode = tmpmode;

            goto do_set;

        }

    };

    {

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

        {

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

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

            {

                mode = tmpmode;

                goto do_set;

            }

        };

    };

    {

        struct drm_framebuffer   *fb;

        struct drm_encoder       *encoder;

        struct drm_crtc          *crtc;

        char *con_name;

        char *enc_name;

        crtc = encoder->crtc;

//                              struct drm_framebuffer, filp_head);

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

        enc_name = drm_get_encoder_name(encoder);

                   reqmode->width, reqmode->height, con_name, enc_name);

        fb->height = reqmode->height;

        fb->pitch  = radeon_align_pitch(dev->dev_private, reqmode->width, 32, false) * ((32 + 1) / 8);

        fb->bits_per_pixel = 32;

        crtc->enabled = true;

        rdisplay->crtc = crtc;

        radeon_show_cursor_kms(crtc);

        {

            rdisplay->width    = fb->width;

            rdisplay->height   = fb->height;

            rdisplay->pitch    = fb->pitch;

            rdisplay->vrefresh = drm_mode_vrefresh(mode);

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

        }

        else

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

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

    }

    return ret;

};

{

    struct drm_display_mode  *mode;

    int count = 0;

    {

        count++;

    };

    return count;

};

{

    struct drm_connector  *connector;

    struct drm_connector_helper_funcs *connector_funcs;

    {

        struct drm_encoder  *encoder;

        struct drm_crtc     *crtc;

            continue;

        encoder = connector_funcs->best_encoder(connector);

        if( encoder == NULL)

            continue;

                   connector, connector->base.id,

                   connector->status, connector->encoder,

                   crtc);

//            continue;

    };

};

{

    struct drm_device   *dev;

    bool                 retval = false;

    u32_t                ifl;

    struct drm_fb_helper *fb_helper;

    {

        list_for_each_entry(cursor, &rdisplay->cursors, list)

        {

            init_cursor(cursor);

        };

    };

    safe_sti(ifl);

    fb_helper = &rfbdev->helper;

//    {

        struct drm_mode_set *mode_set = &fb_helper->crtc_info[0].mode_set;

        struct drm_crtc *crtc;

        struct drm_display_mode *mode;

//            continue;

               crtc->base.id,

               drm_mode_width(mode), drm_mode_height(mode),

               drm_mode_vrefresh(mode));

//    }

    if( rdisplay->connector == 0 )

    {

        dbgprintf("no active connectors\n");

        return false;

    };

              rdisplay->width, rdisplay->height, rdisplay->vrefresh);

    dbgprintf("user mode mode %d x %d x %d\n",

              usermode->width, usermode->height, usermode->freq);

        (usermode->height != 0) &&

        ( (usermode->width  != rdisplay->width)  ||

          (usermode->height != rdisplay->height) ||

          (usermode->freq   != rdisplay->vrefresh) ) )

    {

    }

    {

        rdisplay->restore_cursor(0,0);

        rdisplay->init_cursor    = init_cursor;

        rdisplay->select_cursor  = select_cursor_kms;

        rdisplay->show_cursor    = NULL;

        rdisplay->move_cursor    = move_cursor_kms;

        rdisplay->restore_cursor = restore_cursor;

        rdisplay->disable_mouse  = disable_mouse;

        radeon_show_cursor_kms(rdisplay->crtc);

    };

    safe_sti(ifl);

};

{

    int err = -1;

    {

        *count = rdisplay->supported_modes;

        err = 0;

    }

    else if( mode != NULL )

    {

        struct drm_display_mode  *drmmode;

        int i = 0;

            *count = rdisplay->supported_modes;

        {

            if( i < *count)

            {

                mode->width  = drm_mode_width(drmmode);

                mode->height = drm_mode_height(drmmode);

                mode->bpp    = 32;

                mode->freq   = drm_mode_vrefresh(drmmode);

                i++;

                mode++;

            }

            else break;

        };

        *count = i;

        err = 0;

    };

    LEAVE();

    return err;

}

{

    int err = -1;

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

        (mode->height != 0)  &&

        (mode->freq   != 0 ) &&

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

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

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

    {

        if( set_mode(rdisplay->ddev, rdisplay->connector, mode, true) )

            err = 0;

    };

    return err;

};

                     struct drm_mode_fb_cmd *mode_cmd,

                     struct drm_gem_object **gobj_p)

{

    struct radeon_device *rdev = rfbdev->rdev;

    struct drm_gem_object *gobj = NULL;

    struct radeon_bo *rbo = NULL;

    bool fb_tiled = false; /* useful for testing */

    u32 tiling_flags = 0;

    int ret;

    int aligned_size, size;

    int height = mode_cmd->height;

    static struct drm_mm_node  vm_node;

    mode_cmd->pitch = radeon_align_pitch(rdev, mode_cmd->width, mode_cmd->bpp, fb_tiled) * ((mode_cmd->bpp + 1) / 8);

        height = ALIGN(mode_cmd->height, 8);

    size = mode_cmd->pitch * height;

    aligned_size = ALIGN(size, PAGE_SIZE);

    if (unlikely(ret)) {

        return ret;

    }

    kos_bo.gem_base.driver_private = NULL;

    kos_bo.surface_reg = -1;

    kos_bo.domain = RADEON_GEM_DOMAIN_VRAM;

    rbo = gem_to_radeon_bo(gobj);

        tiling_flags = RADEON_TILING_MACRO;

        rbo->tiling_flags = tiling_flags | RADEON_TILING_SURFACE;

        rbo->pitch = mode_cmd->pitch;

    }

    vm_node.start = 0;

    vm_node.mm = NULL;

    rbo->tbo.offset  = rbo->tbo.vm_node->start << PAGE_SHIFT;

    rbo->tbo.offset += (u64)rbo->rdev->mc.vram_start;

    rbo->kptr        = (void*)0xFE000000;

    rbo->pin_count   = 1;

//        radeon_bo_check_tiling(rbo, 0, 0);

    return 0;

}