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

         fb = fb_helper->fb;
         fb->width  = reqmode->width;
+        fb->height = reqmode->height;
-        fb->height = reqmode->height;
+        fb->pitches[0] = fb->pitches[1] = fb->pitches[2] =
-        fb->pitch  = radeon_align_pitch(dev->dev_private, reqmode->width, 32, false) * ((32 + 1) / 8);
+                         fb->pitches[3] = radeon_align_pitch(dev->dev_private, reqmode->width, 32, false) * ((32 + 1) / 8);
+        fb->bits_per_pixel = 32;
-        fb->bits_per_pixel = 32;
+        fb->depth = 24;
         crtc->fb = fb;
         if (ret == true)
+        {
             rdisplay->width    = fb->width;
             rdisplay->height   = fb->height;
-            rdisplay->pitch    = fb->pitch;
+            rdisplay->pitch    = fb->pitches[0];
             rdisplay->vrefresh = drm_mode_vrefresh(mode);
-            sysSetScreen(fb->width, fb->height, fb->pitch);
+            sysSetScreen(fb->width, fb->height, fb->pitches[0]);
             dbgprintf("new mode %d x %d pitch %d\n",
-                       fb->width, fb->height, fb->pitch);
+                       fb->width, fb->height, fb->pitches[0]);
+        }
         else
             DRM_ERROR("failed to set mode %d_%d on crtc %p\n",
 bool init_display_kms(struct radeon_device *rdev, videomode_t *usermode)
+{
     struct drm_device   *dev;
+    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;
     int i;
     ENTER();
+    dev = rdev->ddev;
+    list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+    {
+        if( connector->status != connector_status_connected)
-    rdisplay = GetDisplay();
+            continue;
+        connector_funcs = connector->helper_private;
-    dev = rdisplay->ddev = rdev->ddev;
+        encoder = connector_funcs->best_encoder(connector);
+        if( encoder == NULL)
+        {
+            dbgprintf("CONNECTOR %x ID: %d no active encoders\n",
+                      connector, connector->base.id);
+            continue;
+        }
+        connector->encoder = encoder;
+        dbgprintf("CONNECTOR %x ID:  %d status %d encoder %x\n crtc %x\n",
+               connector, connector->base.id,
+               connector->status, connector->encoder,
+               encoder->crtc);
+        crtc = encoder->crtc;
         break;
+    };
+    if(connector == NULL)
+    {
+        dbgprintf("No active connectors!\n");
+        return -1;
+    };
+    {
+        struct drm_display_mode *tmp;
-    ifl = safe_cli();
+        list_for_each_entry(tmp, &connector->modes, head) {
+            if (drm_mode_width(tmp) > 16384 ||
+                drm_mode_height(tmp) > 16384)
+                continue;
             if (tmp->type & DRM_MODE_TYPE_PREFERRED)
+            {
+                native = tmp;
+                break;
+            };
+        }
+    }
+    if( ASIC_IS_AVIVO(rdev) && native )
+    {
-        list_for_each_entry(cursor, &rdisplay->cursors, list)
+        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)
+        {
+            if (encoder->possible_crtcs & crtc_mask)
+            {
+                crtc = tmp_crtc;
+                encoder->crtc = crtc;
+                break;
-            init_cursor(cursor);
+            };
-        };
+            crtc_mask <<= 1;
+        };
     };
-    safe_sti(ifl);
-    rfbdev    = rdev->mode_info.rfbdev;
-    fb_helper = &rfbdev->helper;
+    if(crtc == NULL)
+    {
+        dbgprintf("No CRTC for encoder %d\n", encoder->base.id);
+        return -1;
+    };
-//    for (i = 0; i < fb_helper->crtc_count; i++)
-//    {
-        struct drm_mode_set *mode_set = &fb_helper->crtc_info[0].mode_set;
-        struct drm_crtc *crtc;
-        struct drm_display_mode *mode;
+    dbgprintf("[Select CRTC:%d]\n", crtc->base.id);
-        crtc = mode_set->crtc;
-//        if (!crtc->enabled)
-//            continue;
+//    drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
+    rdisplay = GetDisplay();
+    rdisplay->ddev = dev;
-        mode = mode_set->mode;
-        dbgprintf("crtc %d width %d height %d vrefresh %d\n",
-               crtc->base.id,
+    rdisplay->connector = connector;
-               drm_mode_width(mode), drm_mode_height(mode),
+    rdisplay->crtc = crtc;
                drm_mode_vrefresh(mode));
-//    }
+    rdisplay->supported_modes = count_connector_modes(connector);
-    rdisplay->connector = get_def_connector(dev);
+    ifl = safe_cli();
     if( rdisplay->connector == 0 )
         list_for_each_entry(cursor, &rdisplay->cursors, list)
         dbgprintf("no active connectors\n");
-        return false;
+            init_cursor(cursor);
-    };
+        };
+    };
+    safe_sti(ifl);
+    dbgprintf("current mode %d x %d x %d\n",
+              rdisplay->width, rdisplay->height, rdisplay->vrefresh);
     dbgprintf("user mode mode %d x %d x %d\n",
               usermode->width, usermode->height, usermode->freq);
     rdisplay->crtc = rdisplay->connector->encoder->crtc = crtc;
 int get_modes(videomode_t *mode, int *count)
+{
     int err = -1;
-    ENTER();
+//    ENTER();
     dbgprintf("mode %x count %d\n", mode, *count);
         };
         *count = i;
         err = 0;
     };
-    LEAVE();
+//    LEAVE();
     return err;
+}
 int set_user_mode(videomode_t *mode)
+{
     int err = -1;
-    ENTER();
+//    ENTER();
     dbgprintf("width %d height %d vrefresh %d\n",
         if( set_mode(rdisplay->ddev, rdisplay->connector, mode, true) )
             err = 0;
     };
-    LEAVE();
+//    LEAVE();
     return err;
 };
-int radeonfb_create_object(struct radeon_fbdev *rfbdev,
+int radeonfb_create_pinned_object(struct radeon_fbdev *rfbdev,
-                     struct drm_mode_fb_cmd *mode_cmd,
+                     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 aligned_size, size;
+    int height = mode_cmd->height;
-    int height = mode_cmd->height;
+    u32 bpp, depth;
+    static struct radeon_bo kos_bo;
+    static struct drm_mm_node  vm_node;
-    static struct radeon_bo kos_bo;
+    drm_fb_get_bpp_depth(mode_cmd->pixel_format, &depth, &bpp);
     static struct drm_mm_node  vm_node;
     /* need to align pitch with crtc limits */
-    /* need to align pitch with crtc limits */
+    mode_cmd->pitches[0] = radeon_align_pitch(rdev, mode_cmd->width, bpp,
-    mode_cmd->pitch = radeon_align_pitch(rdev, mode_cmd->width, mode_cmd->bpp, fb_tiled) * ((mode_cmd->bpp + 1) / 8);
+                          fb_tiled) * ((bpp + 1) / 8);
     if (rdev->family >= CHIP_R600)
-    if (rdev->family >= CHIP_R600)
+        height = ALIGN(mode_cmd->height, 8);
+    size = mode_cmd->pitches[0] * height;
+    aligned_size = ALIGN(size, PAGE_SIZE);
-        height = ALIGN(mode_cmd->height, 8);
     size = mode_cmd->pitch * height;
-    aligned_size = ALIGN(size, PAGE_SIZE);
+    ret = drm_gem_object_init(rdev->ddev, &kos_bo.gem_base, aligned_size);
     if (unlikely(ret)) {
-    ret = drm_gem_object_init(rdev->ddev, &kos_bo.gem_base, aligned_size);
+        printk(KERN_ERR "failed to allocate framebuffer (%d)\n",
     if (fb_tiled)
         tiling_flags = RADEON_TILING_MACRO;
+//    if (tiling_flags) {
-    if (tiling_flags) {
+//        ret = radeon_bo_set_tiling_flags(rbo,
-        rbo->tiling_flags = tiling_flags | RADEON_TILING_SURFACE;
+//                         tiling_flags | RADEON_TILING_SURFACE,
+//                         mode_cmd->pitches[0]);
+//        if (ret)
-        rbo->pitch = mode_cmd->pitch;
+//            dev_err(rdev->dev, "FB failed to set tiling flags\n");
 //    }
     vm_node.size = 0xC00000 >> 12;
     rbo->tbo.offset += (u64)rbo->rdev->mc.vram_start;
     rbo->kptr        = (void*)0xFE000000;
     rbo->pin_count   = 1;
-//    if (fb_tiled)
-//        radeon_bo_check_tiling(rbo, 0, 0);
     *gobj_p = gobj;
     return 0;
-}

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/radeon/rdisplay_kms.c – Rev 2004 → 2997