WebSVN – Kolibri OS – Diff – /drivers/video/drm/radeon/rdisplay_kms.c

 #include
+#include
 #include
 #include
-#include "radeon_drm.h"
 #include "radeon.h"
 #include "radeon_object.h"
 #include "drm_fb_helper.h"
 #include "hmm.h"
 #include "bitmap.h"
 #include "display.h"
-struct radeon_fbdev {
-    struct drm_fb_helper        helper;
-    struct radeon_framebuffer   rfb;
-    struct list_head fbdev_list;
+extern struct drm_framebuffer *main_fb;
-    struct radeon_device        *rdev;
-};
+extern struct drm_gem_object  *main_fb_obj;
 struct radeon_fbdev *kos_rfbdev;
 display_t *os_display;
     struct radeon_crtc   *radeon_crtc;
     cursor_t *old;
     uint32_t  gpu_addr;
-    rdev = (struct radeon_device *)rdisplay->ddev->dev_private;
+    rdev = (struct radeon_device *)os_display->ddev->dev_private;
-    radeon_crtc = to_radeon_crtc(rdisplay->crtc);
+    radeon_crtc = to_radeon_crtc(os_display->crtc);
-    old = rdisplay->cursor;
+    old = os_display->cursor;
-    rdisplay->cursor = cursor;
+    os_display->cursor = cursor;
     gpu_addr = radeon_bo_gpu_offset(cursor->robj);
 void __stdcall move_cursor_kms(cursor_t *cursor, int x, int y)
+{
     struct radeon_device *rdev;
-    rdev = (struct radeon_device *)rdisplay->ddev->dev_private;
+    rdev = (struct radeon_device *)os_display->ddev->dev_private;
-    struct drm_crtc *crtc = rdisplay->crtc;
+    struct drm_crtc *crtc = os_display->crtc;
     struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
     int hot_x = cursor->hot_x;
     int hot_y = cursor->hot_y;
     return name;
+}
-bool set_mode(struct drm_device *dev, struct drm_connector *connector,
+static int set_mode(struct drm_device *dev, struct drm_connector *connector,
-              videomode_t *reqmode, bool strict)
+                    struct drm_crtc *crtc, videomode_t *reqmode, bool strict)
+{
+    struct drm_display_mode  *mode = NULL, *tmpmode;
+    struct drm_framebuffer  *fb         = NULL;
+    struct drm_mode_set     set;
+    const char *con_name;
+    unsigned hdisplay, vdisplay;
-    struct drm_display_mode  *mode = NULL, *tmpmode;
-    struct drm_fb_helper *fb_helper;
-    fb_helper = &kos_rfbdev->helper;
+    int ret;
-    bool ret = false;
-    ENTER();
     dbgprintf("width %d height %d vrefresh %d\n",
-               reqmode->width, reqmode->height, reqmode->freq);
+    drm_modeset_lock_all(dev);
     list_for_each_entry(tmpmode, &connector->modes, head)
+    {
-        if( (drm_mode_width(tmpmode)    == reqmode->width)  &&
+        if( (tmpmode->hdisplay == reqmode->width)  &&
-            (drm_mode_height(tmpmode)   == reqmode->height) &&
+            (tmpmode->vdisplay == reqmode->height) &&
             (drm_mode_vrefresh(tmpmode) == reqmode->freq) )
+        {
     if( (mode == NULL) && (strict == false) )
+    {
         list_for_each_entry(tmpmode, &connector->modes, head)
+        {
-            if( (drm_mode_width(tmpmode)  == reqmode->width)  &&
+            if( (tmpmode->hdisplay == reqmode->width)  &&
-                (drm_mode_height(tmpmode) == reqmode->height) )
+                (tmpmode->vdisplay == reqmode->height) )
+            {
                 mode = tmpmode;
                 goto do_set;
+            }
-        };
+       };
     };
-do_set:
-    if( mode != NULL )
-    {
-        struct drm_framebuffer   *fb;
-        struct drm_encoder       *encoder;
-        struct drm_crtc          *crtc;
-//        char  con_edid[128];
+    DRM_ERROR("%s failed\n", __FUNCTION__);
-        char *con_name;
-        char *enc_name;
-        encoder = connector->encoder;
+    return -1;
-        crtc = encoder->crtc;
+do_set:
-//        fb = list_first_entry(&dev->mode_config.fb_kernel_list,
+    con_name = connector->name;
-//                              struct drm_framebuffer, filp_head);
-//        memcpy(con_edid, connector->edid_blob_ptr->data, 128);
-//        dbgprintf("Manufacturer: %s Model %x Serial Number %u\n",
+    DRM_DEBUG_KMS("set mode %d %d: crtc %d connector %s\n",
-//        manufacturer_name(con_edid + 0x08),
+              reqmode->width, reqmode->height, crtc->base.id,
-//        (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),
+              con_name);
-//        (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)
-//            + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));
+    drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
+    hdisplay = mode->hdisplay;
+    vdisplay = mode->vdisplay;
-        con_name = drm_get_connector_name(connector);
-        enc_name = drm_get_encoder_name(encoder);
+    if (crtc->invert_dimensions)
         swap(hdisplay, vdisplay);
         dbgprintf("set mode %d %d connector %s encoder %s\n",
-                   reqmode->width, reqmode->height, con_name, enc_name);
     fb = main_fb;
-        fb = fb_helper->fb;
+    fb->width  = reqmode->width;
+    fb->height = reqmode->height;
+    fb->pitches[0] =
+    fb->pitches[1] =
+    fb->pitches[2] =
+    fb->pitches[3] = radeon_align_pitch(dev->dev_private, reqmode->width, 32, false) * ((32 + 1) / 8);
+    fb->bits_per_pixel = 32;
+    fb->depth = 24;
+    crtc->enabled = true;
-        fb->width  = reqmode->width;
+    os_display->crtc = crtc;
         fb->height = reqmode->height;
+    set.crtc = crtc;
-        fb->pitches[0] = fb->pitches[1] = fb->pitches[2] =
+    set.x = 0;
-                         fb->pitches[3] = radeon_align_pitch(dev->dev_private, reqmode->width, 32, false) * ((32 + 1) / 8);
+    set.y = 0;
-        fb->bits_per_pixel = 32;
+    set.mode = mode;
-        fb->depth = 24;
+    set.connectors = &connector;
-        crtc->fb = fb;
+    set.num_connectors = 1;
-        crtc->enabled = true;
+    set.fb = fb;
         rdisplay->crtc = crtc;
     ret = drm_mode_set_config_internal(&set);
         ret = drm_crtc_helper_set_mode(crtc, mode, 0, 0, fb);
     drm_modeset_unlock_all(dev);
         select_cursor_kms(rdisplay->cursor);
-        radeon_show_cursor_kms(crtc);
-        if (ret == true)
+    select_cursor_kms(os_display->cursor);
-        {
+    radeon_show_cursor_kms(crtc);
             rdisplay->width    = fb->width;
-            rdisplay->height   = fb->height;
+    if ( !ret )
             rdisplay->pitch    = fb->pitches[0];
-            rdisplay->vrefresh = drm_mode_vrefresh(mode);
+        os_display->width    = fb->width;
     };
     return count;
 };
-static struct drm_connector* get_def_connector(struct drm_device *dev)
+static struct drm_crtc *get_possible_crtc(struct drm_device *dev, struct drm_encoder *encoder)
+{
-    struct drm_connector  *connector;
+    struct drm_crtc *tmp_crtc;
-    struct drm_connector_helper_funcs *connector_funcs;
+    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;
-    struct drm_connector  *def_connector = NULL;
+};
 static int choose_config(struct drm_device *dev, struct drm_connector **boot_connector,
+                  struct drm_crtc **boot_crtc)
+{
-    list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+    struct drm_connector_helper_funcs *connector_funcs;
     struct drm_connector *connector;
+    struct drm_encoder   *encoder;
+    struct drm_crtc      *crtc;
         struct drm_encoder  *encoder;
-        struct drm_crtc     *crtc;
+    list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+    {
+        if( connector->status != connector_status_connected)
+            continue;
         encoder = connector->encoder;
         if( connector->status != connector_status_connected)
+        if(encoder == NULL)
             continue;
+            connector_funcs = connector->helper_private;
+            encoder = connector_funcs->best_encoder(connector);
             if( encoder == NULL)
-        connector_funcs = connector->helper_private;
-        encoder = connector_funcs->best_encoder(connector);
+            {
+                DRM_DEBUG_KMS("CONNECTOR %x ID: %d no active encoders\n",
-        if( encoder == NULL)
+                        connector, connector->base.id);
+                continue;
+            };
+        }
+        crtc = encoder->crtc;
+        if(crtc == NULL)
+            crtc = get_possible_crtc(dev, encoder);
-            continue;
+        if(crtc != NULL)
-        connector->encoder = encoder;
+        {
+            *boot_connector = connector;
-        crtc = encoder->crtc;
+            *boot_crtc = crtc;
-        dbgprintf("CONNECTOR %x ID:  %d status %d encoder %x\n crtc %x",
+            connector->encoder = encoder;
-                   connector, connector->base.id,
-                   connector->status, connector->encoder,
+            DRM_DEBUG_KMS("CONNECTOR %p ID:%d status:%d ENCODER %p ID: %d CRTC %p ID:%d\n",
-                   crtc);
                            connector, connector->base.id, connector->status,
-//        if (crtc == NULL)
+                           encoder, encoder->base.id, crtc, crtc->base.id );
-//            continue;
+            return 0;
+        }
+        else
+            DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id);
+    };
+    return -ENOENT;
+};
-        def_connector = connector;
+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)
+    {
-        break;
+        DRM_DEBUG_KMS("check mode w:%d h:%d %dHz\n",
+                mode->hdisplay, mode->vdisplay,
+                drm_mode_vrefresh(mode));
+        if( os_display->width  == mode->hdisplay &&
+            os_display->height == mode->vdisplay &&
-    };
+            drm_mode_vrefresh(mode) == 60)
+        {
             usermode->width  = os_display->width;
-    return def_connector;
+            usermode->height = os_display->height;
-};
+            usermode->freq   = 60;
             return 1;
 bool init_display_kms(struct radeon_device *rdev, videomode_t *usermode)
-{
     struct drm_device   *dev;
+    return 0;
+}
-    struct drm_connector    *connector;
-    struct drm_connector_helper_funcs *connector_funcs;
-    struct drm_encoder      *encoder;
-    struct drm_crtc         *crtc = NULL;
-    struct drm_framebuffer  *fb;
-    struct drm_display_mode *native;
-    cursor_t            *cursor;
-    bool                 retval = false;
-    u32_t                ifl;
-    struct radeon_fbdev  *rfbdev;
-    struct drm_fb_helper *fb_helper;
+int init_display_kms(struct drm_device *dev, videomode_t *usermode)
     int i;
-    ENTER();
+    struct drm_connector_helper_funcs *connector_funcs;
-    dev = rdev->ddev;
-    list_for_each_entry(connector, &dev->mode_config.connector_list, head)
-    {
-        if( connector->status != connector_status_connected)
-            continue;
-        connector_funcs = connector->helper_private;
-        encoder = connector_funcs->best_encoder(connector);
-        if( encoder == NULL)
-        {
-            dbgprintf("CONNECTOR %x ID: %d no active encoders\n",
-                      connector, connector->base.id);
-            continue;
-        }
+    struct drm_connector    *connector = NULL;
-        connector->encoder = encoder;
+    struct drm_crtc         *crtc = NULL;
     struct drm_framebuffer  *fb;
         dbgprintf("CONNECTOR %x ID:  %d status %d encoder %x\n crtc %x\n",
-               connector, connector->base.id,
+    cursor_t            *cursor;
+    u32_t                ifl;
-               connector->status, connector->encoder,
+    int        ret;
-               encoder->crtc);
+    mutex_lock(&dev->mode_config.mutex);
         crtc = encoder->crtc;
-        break;
+    ret = choose_config(dev, &connector, &crtc);
-    };
+    if(ret)
+    {
-    if(connector == NULL)
+        DRM_DEBUG_KMS("No active connectors!\n");
         mutex_unlock(&dev->mode_config.mutex);
-        dbgprintf("No active connectors!\n");
+        return -1;
-        return -1;
     };
-    {
         struct drm_display_mode *tmp;
         struct drm_display_mode *tmp, *native = NULL;
-        list_for_each_entry(tmp, &connector->modes, head) {
+        struct radeon_device *rdev = dev->dev_private;
             if (drm_mode_width(tmp) > 16384 ||
+        list_for_each_entry(tmp, &connector->modes, head) {
+            if (tmp->hdisplay > 16384 ||
+                tmp->vdisplay > 16384)
+                continue;
-                drm_mode_height(tmp) > 16384)
-                continue;
-            if (tmp->type & DRM_MODE_TYPE_PREFERRED)
-            {
+            if (tmp->type & DRM_MODE_TYPE_PREFERRED)
-                native = tmp;
-                break;
+            {
-            };
-        }
-    }
-    if( ASIC_IS_AVIVO(rdev) && native )
-    {
-        dbgprintf("native w %d h %d\n", native->hdisplay, native->vdisplay);
-        struct radeon_encoder *radeon_encoder = to_radeon_encoder(connector->encoder);
-        radeon_encoder->rmx_type = RMX_FULL;
-        radeon_encoder->native_mode = *native;
-    };
-    if(crtc == NULL)
-    {
-        struct drm_crtc *tmp_crtc;
-        int crtc_mask = 1;
-        list_for_each_entry(tmp_crtc, &dev->mode_config.crtc_list, head)
+                native = tmp;
+                break;
-        {
+            };
-            if (encoder->possible_crtcs & crtc_mask)
-            {
-                crtc = tmp_crtc;
+        }
-                encoder->crtc = crtc;
+        if( ASIC_IS_AVIVO(rdev) && native )
+        {
-                break;
+            struct radeon_encoder *radeon_encoder = to_radeon_encoder(connector->encoder);
+            radeon_encoder->rmx_type = RMX_FULL;
+            radeon_encoder->native_mode = *native;
+        };
+    }
+#if 0
-            };
+    mutex_lock(&dev->object_name_lock);
-            crtc_mask <<= 1;
+    idr_preload(GFP_KERNEL);
-        };
-    };
+    if (!main_fb_obj->name) {
         ret = idr_alloc(&dev->object_name_idr, &main_fb_obj, 1, 0, GFP_NOWAIT);
     if(crtc == NULL)
+        main_fb_obj->name = ret;
+        /* Allocate a reference for the name table.  */
+        drm_gem_object_reference(main_fb_obj);
+        DRM_DEBUG_KMS("%s allocate fb name %d\n", __FUNCTION__, main_fb_obj->name );
+    }
     idr_preload_end();
-        dbgprintf("No CRTC for encoder %d\n", encoder->base.id);
+    mutex_unlock(&dev->object_name_lock);
-        return -1;
+    drm_gem_object_unreference(main_fb_obj);
-    };
+#endif
+    os_display = GetDisplay();
-    dbgprintf("[Select CRTC:%d]\n", crtc->base.id);
+    os_display->ddev = dev;
+    os_display->connector = connector;
-//    drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
-    rdisplay = GetDisplay();
-    rdisplay->ddev = dev;
+    os_display->crtc = crtc;
-    rdisplay->connector = connector;
-    rdisplay->crtc = crtc;
-    rdisplay->supported_modes = count_connector_modes(connector);
     os_display->supported_modes = count_connector_modes(connector);
-    ifl = safe_cli();
-    {
-        list_for_each_entry(cursor, &rdisplay->cursors, list)
-        {
-            init_cursor(cursor);
-        };
-    };
-    safe_sti(ifl);
-    dbgprintf("current mode %d x %d x %d\n",
-              rdisplay->width, rdisplay->height, rdisplay->vrefresh);
+    ifl = safe_cli();
-    dbgprintf("user mode mode %d x %d x %d\n",
+    {
-              usermode->width, usermode->height, usermode->freq);
+        list_for_each_entry(cursor, &os_display->cursors, list)
+        {
             init_cursor(cursor);
+        };
+        os_display->restore_cursor(0,0);
-    if( (usermode->width  != 0) &&
+        os_display->init_cursor    = init_cursor;
-        (usermode->height != 0) &&
+        os_display->select_cursor  = select_cursor_kms;
-        ( (usermode->width  != rdisplay->width)  ||
+        os_display->show_cursor    = NULL;
-          (usermode->height != rdisplay->height) ||
+        os_display->move_cursor    = move_cursor_kms;
+        os_display->restore_cursor = restore_cursor;
-          (usermode->freq   != rdisplay->vrefresh) ) )
+        os_display->disable_mouse  = disable_mouse;
         select_cursor_kms(os_display->cursor);
     };
-        retval = set_mode(dev, rdisplay->connector, usermode, false);
-    }
-    else
-    {
-        usermode->width  = rdisplay->width;
+    safe_sti(ifl);
         usermode->height = rdisplay->height;
-        usermode->freq   = 60;
-        retval = set_mode(dev, rdisplay->connector, usermode, false);
+//    dbgprintf("current mode %d x %d x %d\n",
-    };
+//              os_display->width, os_display->height, os_display->vrefresh);
 //    dbgprintf("user mode mode %d x %d x %d\n",
-    ifl = safe_cli();
+//              usermode->width, usermode->height, usermode->freq);
-        rdisplay->restore_cursor(0,0);
+    if( (usermode->width == 0) ||
-        rdisplay->init_cursor    = init_cursor;
+        (usermode->height == 0))
-        rdisplay->select_cursor  = select_cursor_kms;
+    {
-        rdisplay->show_cursor    = NULL;
+        if( !get_boot_mode(connector, usermode))
         rdisplay->move_cursor    = move_cursor_kms;
-        rdisplay->restore_cursor = restore_cursor;
+            struct drm_display_mode *mode;
         rdisplay->disable_mouse  = disable_mouse;
+            mode = list_entry(connector->modes.next, typeof(*mode), head);
-        select_cursor_kms(rdisplay->cursor);
+            usermode->width  = mode->hdisplay;
-        radeon_show_cursor_kms(rdisplay->crtc);
+            usermode->height = mode->vdisplay;
-    };
+            usermode->freq   = drm_mode_vrefresh(mode);
-    safe_sti(ifl);
+        };
     };
 //    init_bitmaps();
     mutex_unlock(&dev->mode_config.mutex);
     LEAVE();
     set_mode(dev, os_display->connector, os_display->crtc, usermode, false);
     return retval;
-};
+    radeon_show_cursor_kms(os_display->crtc);
 int get_modes(videomode_t *mode, int *count)
-{
+    return 0;
-    int err = -1;
+};
 //    ENTER();
-    dbgprintf("mode %x count %d\n", mode, *count);
-    if( *count == 0 )
-    {
-        *count = rdisplay->supported_modes;
+int get_videomodes(videomode_t *mode, int *count)
         err = 0;
     int err = -1;
-    else if( mode != NULL )
-    {
+    if( *count == 0 )
-        struct drm_display_mode  *drmmode;
+    {
-        int i = 0;
+        *count = os_display->supported_modes;
+        err = 0;
-        if( *count > rdisplay->supported_modes)
             *count = rdisplay->supported_modes;
-        list_for_each_entry(drmmode, &rdisplay->connector->modes, head)
+    else if( mode != NULL )
+    {
-            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 set_user_mode(videomode_t *mode)
-{
-    int err = -1;
-//    ENTER();
-    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   != rdisplay->width)  ||
-          (mode->height  != rdisplay->height) ||
-          (mode->freq    != rdisplay->vrefresh) ) )
-    {
-        if( set_mode(rdisplay->ddev, rdisplay->connector, mode, true) )
-            err = 0;
-    };
-//    LEAVE();
-    return err;
-};
-int radeonfb_create_pinned_object(struct radeon_fbdev *rfbdev,
-                     struct drm_mode_fb_cmd2 *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;
-    u32 bpp, depth;
-    static struct radeon_bo kos_bo;
-    static struct drm_mm_node  vm_node;
-    drm_fb_get_bpp_depth(mode_cmd->pixel_format, &depth, &bpp);
-    /* need to align pitch with crtc limits */
-    mode_cmd->pitches[0] = radeon_align_pitch(rdev, mode_cmd->width, bpp,
-                          fb_tiled) * ((bpp + 1) / 8);
-    if (rdev->family >= CHIP_R600)
-        height = ALIGN(mode_cmd->height, 8);
-    size = mode_cmd->pitches[0] * height;
-    aligned_size = ALIGN(size, PAGE_SIZE);
         struct drm_display_mode  *drmmode;
-#ifndef __TTM__
+        int i = 0;
     ret = drm_gem_object_init(rdev->ddev, &kos_bo.gem_base, aligned_size);
-    if (unlikely(ret)) {
+        if( *count > os_display->supported_modes)
     int bottom;
 }rect_t;
 extern struct hmm bm_mm;
-struct drm_device *main_drm_device;
+struct drm_device *main_device;
 void  FASTCALL GetWindowRect(rect_t *rc)__asm__("GetWindowRect");
 #define CURRENT_TASK             (0x80003000)
 static u32_t get_display_map()
+{
     u32_t   addr;
-    addr = (u32_t)rdisplay;
+    addr = (u32_t)os_display;
         src_offset = (u8*)(src_y*bitmap->pitch + src_x*4);
         src_offset += (u32)bitmap->uaddr;
-        dst_offset = (u8*)(dst_y*rdisplay->width + dst_x);
+        dst_offset = (u8*)(dst_y*os_display->width + dst_x);
         dst_offset+= get_display_map();
             u32* tmp_src = src_offset;
             u8*  tmp_dst = dst_offset;
             src_offset+= bitmap->pitch;
-            dst_offset+= rdisplay->width;
+            dst_offset+= os_display->width;
             while( tmp_w--)
                   RADEON_DP_SRC_SOURCE_MEMORY |
                   RADEON_GMC_WR_MSK_DIS;
     ib->ptr[4] = ((bitmap->pitch/64) << 22) | (bitmap->gaddr >> 10);
-    ib->ptr[5] = ((rdisplay->pitch/64) << 22) | (rdev->mc.vram_start >> 10);
+    ib->ptr[5] = ((os_display->pitch/64) << 22) | (rdev->mc.vram_start >> 10);
     ib->ptr[6] = (0x1fff) | (0x1fff << 16);
     ib->ptr[7] = 0;
     ib->ptr[8] = (0x1fff) | (0x1fff << 16);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/radeon/rdisplay_kms.c – Rev 3764 → 5078