Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 4079 → Rev 4080

/drivers/video/drm/vmwgfx/Makefile
1,5 → 1,4
 
 
CC = gcc
LD = ld
AS = as
/drivers/video/drm/vmwgfx/bitmap.h
0,0 → 1,106
 
typedef struct tag_object kobj_t;
typedef struct tag_display display_t;
 
 
struct tag_object
{
uint32_t magic;
void *destroy;
kobj_t *fd;
kobj_t *bk;
uint32_t pid;
};
 
typedef struct
{
kobj_t header;
 
u32 handle;
char *uaddr;
 
u32 pitch;
u32 gaddr;
 
u32 width;
u32 height;
u32 max_width;
u32 max_height;
u32 page_count;
u32 max_count;
 
u32 format;
// struct drm_i915_gem_object *obj;
}bitmap_t;
 
 
struct io_call_10 /* SRV_CREATE_SURFACE */
{
u32 handle; // ignored
void *data; // ignored
 
u32 width;
u32 height;
u32 pitch; // ignored
 
u32 max_width;
u32 max_height;
u32 format; // reserved mbz
};
 
struct io_call_12 /* SRV_LOCK_SURFACE */
{
u32 handle;
void *data;
u32 pitch;
};
 
struct io_call_14 /* SRV_RESIZE_SURFACE */
{
u32 handle;
void *data;
u32 new_width;
u32 new_height;
u32 pitch;
};
 
typedef struct
{
uint32_t idx;
union
{
uint32_t opt[2];
struct {
uint32_t max_tex_width;
uint32_t max_tex_height;
}cap1;
};
}hwcaps_t;
 
#define HW_BIT_BLIT (1<<0) /* BGRX blitter */
#define HW_TEX_BLIT (1<<1) /* stretch blit */
#define HW_VID_BLIT (1<<2) /* planar and packed video */
/* 3 - 63 reserved */
struct context
{
kobj_t header;
 
// struct drm_i915_gem_object *obj;
u32 cmd_buffer;
u32 cmd_offset;
 
bitmap_t *mask;
u32 seqno;
int slot;
 
};
 
int get_driver_caps(hwcaps_t *caps);
int create_surface(struct drm_device *dev, struct io_call_10 *pbitmap);
int lock_surface(struct io_call_12 *pbitmap);
int resize_surface(struct io_call_14 *pbitmap);
 
struct context *get_context(struct drm_device *dev);
 
int init_bitmaps();
 
/drivers/video/drm/vmwgfx/main.c
59,7 → 59,7
int x86_clflush_size;
unsigned int tsc_khz;
 
int i915_modeset = 1;
int kms_modeset = 1;
 
u32_t __attribute__((externally_visible)) drvEntry(int action, char *cmdline)
{
98,7 → 98,6
enum_pci_devices();
 
err = vmw_init();
 
if(err)
{
dbgprintf("Epic Fail :(\n");
187,24 → 186,25
*outp = DISPLAY_VERSION;
retval = 0;
break;
#if 0
 
case SRV_ENUM_MODES:
// dbgprintf("SRV_ENUM_MODES inp %x inp_size %x out_size %x\n",
// inp, io->inp_size, io->out_size );
dbgprintf("SRV_ENUM_MODES inp %x inp_size %x out_size %x\n",
inp, io->inp_size, io->out_size );
check_output(4);
// check_input(*outp * sizeof(videomode_t));
if( i915_modeset)
if( kms_modeset)
retval = get_videomodes((videomode_t*)inp, outp);
break;
 
case SRV_SET_MODE:
// dbgprintf("SRV_SET_MODE inp %x inp_size %x\n",
// inp, io->inp_size);
dbgprintf("SRV_SET_MODE inp %x inp_size %x\n",
inp, io->inp_size);
check_input(sizeof(videomode_t));
if( i915_modeset )
if( kms_modeset )
retval = set_user_mode((videomode_t*)inp);
break;
 
#if 0
case SRV_GET_CAPS:
retval = get_driver_caps((hwcaps_t*)inp);
break;
810,3 → 810,262
}
 
 
 
 
 
 
 
 
 
 
 
 
#include "vmwgfx_kms.h"
 
void kms_update();
 
//#define iowrite32(v, addr) writel((v), (addr))
 
//#include "bitmap.h"
 
extern struct drm_device *main_device;
 
typedef struct
{
kobj_t header;
 
uint32_t *data;
uint32_t hot_x;
uint32_t hot_y;
 
struct list_head list;
// struct drm_i915_gem_object *cobj;
}cursor_t;
 
#define CURSOR_WIDTH 64
#define CURSOR_HEIGHT 64
 
struct tag_display
{
int x;
int y;
int width;
int height;
int bpp;
int vrefresh;
int pitch;
int lfb;
 
int supported_modes;
struct drm_device *ddev;
struct drm_connector *connector;
struct drm_crtc *crtc;
 
struct list_head cursors;
 
cursor_t *cursor;
int (*init_cursor)(cursor_t*);
cursor_t* (__stdcall *select_cursor)(cursor_t*);
void (*show_cursor)(int show);
void (__stdcall *move_cursor)(cursor_t *cursor, int x, int y);
void (__stdcall *restore_cursor)(int x, int y);
void (*disable_mouse)(void);
u32 mask_seqno;
u32 check_mouse;
u32 check_m_pixel;
u32 dirty;
void (*update)(void);
};
 
static display_t *os_display;
 
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;
};
 
int kms_init(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;
 
cursor_t *cursor;
int mode_count;
u32_t ifl;
int err;
 
ENTER();
 
crtc = list_entry(dev->mode_config.crtc_list.next, typeof(*crtc), head);
encoder = list_entry(dev->mode_config.encoder_list.next, typeof(*encoder), head);
connector = list_entry(dev->mode_config.connector_list.next, typeof(*connector), head);
connector->encoder = encoder;
 
mode_count = count_connector_modes(connector);
if(mode_count == 0)
{
struct drm_display_mode *mode;
 
connector->funcs->fill_modes(connector,
dev->mode_config.max_width,
dev->mode_config.max_height);
 
list_for_each_entry(mode, &connector->modes, head)
mode_count++;
};
 
printf("%s %d\n",__FUNCTION__, mode_count);
 
DRM_DEBUG_KMS("CONNECTOR %x ID:%d status:%d ENCODER %x CRTC %x ID:%d\n",
connector, connector->base.id,
connector->status, connector->encoder,
crtc, crtc->base.id );
 
DRM_DEBUG_KMS("[Select CRTC:%d]\n", crtc->base.id);
 
os_display = GetDisplay();
 
ifl = safe_cli();
{
os_display->ddev = dev;
os_display->connector = connector;
os_display->crtc = crtc;
os_display->supported_modes = mode_count;
os_display->update = kms_update;
 
// struct intel_crtc *intel_crtc = to_intel_crtc(os_display->crtc);
 
// 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;
 
// intel_crtc->cursor_x = os_display->width/2;
// intel_crtc->cursor_y = os_display->height/2;
 
// select_cursor_kms(os_display->cursor);
};
safe_sti(ifl);
 
main_device = dev;
 
#ifdef __HWA__
err = init_bitmaps();
#endif
 
LEAVE();
 
return 0;
};
 
 
void kms_update()
{
struct vmw_private *dev_priv = vmw_priv(main_device);
size_t fifo_size;
int i;
 
struct {
uint32_t header;
SVGAFifoCmdUpdate body;
} *cmd;
 
fifo_size = sizeof(*cmd);
 
cmd = vmw_fifo_reserve(dev_priv, fifo_size);
if (unlikely(cmd == NULL)) {
DRM_ERROR("Fifo reserve failed.\n");
return;
}
 
cmd->header = cpu_to_le32(SVGA_CMD_UPDATE);
cmd->body.x = 0;
cmd->body.y = 0;
cmd->body.width = os_display->width; //cpu_to_le32(clips->x2 - clips->x1);
cmd->body.height = os_display->height; //cpu_to_le32(clips->y2 - clips->y1);
 
vmw_fifo_commit(dev_priv, fifo_size);
}
 
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 = 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;
};
return err;
};
 
 
bool set_mode(struct drm_device *dev, struct drm_connector *connector,
videomode_t *reqmode, bool strict);
 
 
int set_user_mode(videomode_t *mode)
{
int err = -1;
 
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) ) )
{
if( set_mode(os_display->ddev, os_display->connector, mode, true) )
err = 0;
};
 
return err;
};
 
/drivers/video/drm/vmwgfx/vmwgfx_drv.c
634,6 → 634,7
// vmw_fb_init(dev_priv);
}
 
LEAVE();
return 0;
 
out_no_fifo:
962,6 → 963,122
vmw_fb_on(dev_priv);
}
 
 
static void vmw_remove(struct pci_dev *pdev)
{
struct drm_device *dev = pci_get_drvdata(pdev);
 
drm_put_dev(dev);
}
 
static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val,
void *ptr)
{
struct vmw_private *dev_priv =
container_of(nb, struct vmw_private, pm_nb);
struct vmw_master *vmaster = dev_priv->active_master;
 
switch (val) {
case PM_HIBERNATION_PREPARE:
case PM_SUSPEND_PREPARE:
ttm_suspend_lock(&vmaster->lock);
 
/**
* This empties VRAM and unbinds all GMR bindings.
* Buffer contents is moved to swappable memory.
*/
vmw_execbuf_release_pinned_bo(dev_priv);
vmw_resource_evict_all(dev_priv);
ttm_bo_swapout_all(&dev_priv->bdev);
 
break;
case PM_POST_HIBERNATION:
case PM_POST_SUSPEND:
case PM_POST_RESTORE:
ttm_suspend_unlock(&vmaster->lock);
 
break;
case PM_RESTORE_PREPARE:
break;
default:
break;
}
return 0;
}
 
/**
* These might not be needed with the virtual SVGA device.
*/
 
static int vmw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
{
struct drm_device *dev = pci_get_drvdata(pdev);
struct vmw_private *dev_priv = vmw_priv(dev);
 
if (dev_priv->num_3d_resources != 0) {
DRM_INFO("Can't suspend or hibernate "
"while 3D resources are active.\n");
return -EBUSY;
}
 
pci_save_state(pdev);
pci_disable_device(pdev);
pci_set_power_state(pdev, PCI_D3hot);
return 0;
}
 
static int vmw_pci_resume(struct pci_dev *pdev)
{
pci_set_power_state(pdev, PCI_D0);
pci_restore_state(pdev);
return pci_enable_device(pdev);
}
 
static int vmw_pm_suspend(struct device *kdev)
{
struct pci_dev *pdev = to_pci_dev(kdev);
struct pm_message dummy;
 
dummy.event = 0;
 
return vmw_pci_suspend(pdev, dummy);
}
 
static int vmw_pm_resume(struct device *kdev)
{
struct pci_dev *pdev = to_pci_dev(kdev);
 
return vmw_pci_resume(pdev);
}
 
static int vmw_pm_prepare(struct device *kdev)
{
struct pci_dev *pdev = to_pci_dev(kdev);
struct drm_device *dev = pci_get_drvdata(pdev);
struct vmw_private *dev_priv = vmw_priv(dev);
 
/**
* Release 3d reference held by fbdev and potentially
* stop fifo.
*/
dev_priv->suspended = true;
if (dev_priv->enable_fb)
vmw_3d_resource_dec(dev_priv, true);
 
if (dev_priv->num_3d_resources != 0) {
 
DRM_INFO("Can't suspend or hibernate "
"while 3D resources are active.\n");
 
if (dev_priv->enable_fb)
vmw_3d_resource_inc(dev_priv, true);
dev_priv->suspended = false;
return -EBUSY;
}
 
return 0;
}
 
#endif
 
 
1005,6 → 1122,41
// .patchlevel = VMWGFX_DRIVER_PATCHLEVEL
};
 
 
int vmw_init(void)
{
static pci_dev_t device;
const struct pci_device_id *ent;
int err;
 
ENTER();
 
ent = find_pci_device(&device, vmw_pci_id_list);
if( unlikely(ent == NULL) )
{
dbgprintf("device not found\n");
return -ENODEV;
};
 
DRM_INFO("device %x:%x\n", device.pci_dev.vendor,
device.pci_dev.device);
drm_global_init();
 
err = drm_get_dev(&device.pci_dev, ent);
LEAVE();
 
return err;
}
 
 
 
//module_init(vmwgfx_init);
//module_exit(vmwgfx_exit);
 
MODULE_AUTHOR("VMware Inc. and others");
MODULE_DESCRIPTION("Standalone drm driver for the VMware SVGA device");
MODULE_LICENSE("GPL and additional rights");
 
int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent)
{
static struct drm_device drm_dev;
1066,7 → 1218,7
if (ret)
goto err_g4;
 
// ret = init_display_kms(dev);
ret = kms_init(dev);
 
if (ret)
goto err_g4;
1083,37 → 1235,3
 
return ret;
}
 
int vmw_init(void)
{
static pci_dev_t device;
const struct pci_device_id *ent;
int err;
 
ent = find_pci_device(&device, vmw_pci_id_list);
if( unlikely(ent == NULL) )
{
dbgprintf("device not found\n");
return -ENODEV;
};
 
 
DRM_INFO("device %x:%x\n", device.pci_dev.vendor,
device.pci_dev.device);
 
drm_global_init();
 
err = drm_get_dev(&device.pci_dev, ent);
 
return err;
}
 
 
 
//module_init(vmwgfx_init);
//module_exit(vmwgfx_exit);
 
MODULE_AUTHOR("VMware Inc. and others");
MODULE_DESCRIPTION("Standalone drm driver for the VMware SVGA device");
MODULE_LICENSE("GPL and additional rights");
 
/drivers/video/drm/vmwgfx/vmwgfx_drv.h
414,7 → 414,6
return val;
}
 
 
int vmw_3d_resource_inc(struct vmw_private *dev_priv, bool unhide_svga);
void vmw_3d_resource_dec(struct vmw_private *dev_priv, bool hide_svga);
 
783,5 → 782,12
return (struct ttm_mem_global *) dev_priv->mem_global_ref.object;
}
 
typedef struct
{
int width;
int height;
int bpp;
int freq;
}videomode_t;
 
#endif
/drivers/video/drm/vmwgfx/vmwgfx_fifo.c
398,7 → 398,7
chunk_size = bytes;
 
iowrite32(bytes, fifo_mem + SVGA_FIFO_RESERVED);
// mb();
mb();
memcpy(fifo_mem + (next_cmd >> 2), buffer, chunk_size);
rest = bytes - chunk_size;
if (rest)
466,7 → 466,7
 
if (reserveable)
iowrite32(0, fifo_mem + SVGA_FIFO_RESERVED);
// mb();
mb();
// up_write(&fifo_state->rwsem);
vmw_fifo_ping_host(dev_priv, SVGA_SYNC_GENERIC);
mutex_unlock(&fifo_state->fifo_mutex);
/drivers/video/drm/vmwgfx/vmwgfx_gmr.c
28,11 → 28,10
#define rmb() asm volatile("lfence" : : : "memory")
#define wmb() asm volatile("sfence" : : : "memory")
 
#include "vmwgfx_drv.h"
#include <drm/drmP.h>
#include <drm/ttm/ttm_bo_driver.h>
#include "vmwgfx_drv.h"
 
 
#define VMW_PPN_SIZE sizeof(unsigned long)
 
static int vmw_gmr2_bind(struct vmw_private *dev_priv,
/drivers/video/drm/vmwgfx/vmwgfx_kms.c
1897,6 → 1897,10
{ DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 218250, 1856, 1952,
2176, 2528, 0, 1392, 1393, 1396, 1439, 0,
DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
{ DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 148500, 1920, 2008,
2052, 2200, 0, 1080, 1084, 1089, 1125, 0,
DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC),
.vrefresh = 60, },
/* 1920x1200@60Hz */
{ DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 193250, 1920, 2056,
2256, 2592, 0, 1200, 1203, 1209, 1245, 0,
1906,9 → 1910,9
2256, 2600, 0, 1440, 1441, 1444, 1500, 0,
DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
/* 2560x1600@60Hz */
{ DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 348500, 2560, 2752,
/* { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 348500, 2560, 2752,
3032, 3504, 0, 1600, 1603, 1609, 1658, 0,
DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) }, */
/* Terminate */
{ DRM_MODE("", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) },
};
/drivers/video/drm/vmwgfx/vmwgfx_kms.h
32,7 → 32,7
#include <drm/drm_crtc_helper.h>
#include "vmwgfx_drv.h"
 
#define VMWGFX_NUM_DISPLAY_UNITS 8
#define VMWGFX_NUM_DISPLAY_UNITS 1
 
 
#define vmw_framebuffer_to_vfb(x) \
/drivers/video/drm/vmwgfx/vmwgfx_scrn.c
100,7 → 100,7
/**
* Send the fifo command to create a screen.
*/
static int vmw_sou_fifo_create(struct vmw_private *dev_priv,
int vmw_sou_fifo_create(struct vmw_private *dev_priv,
struct vmw_screen_object_unit *sou,
uint32_t x, uint32_t y,
struct drm_display_mode *mode)
114,8 → 114,10
SVGAScreenObject obj;
} *cmd;
 
BUG_ON(!sou->buffer);
// BUG_ON(!sou->buffer);
 
ENTER();
 
fifo_size = sizeof(*cmd);
cmd = vmw_fifo_reserve(dev_priv, fifo_size);
/* The hardware has hung, nothing we can do about it here. */
141,7 → 143,10
}
 
/* Ok to assume that buffer is pinned in vram */
vmw_bo_get_guest_ptr(&sou->buffer->base, &cmd->obj.backingStore.ptr);
// vmw_bo_get_guest_ptr(&sou->buffer->base, &cmd->obj.backingStore.ptr);
 
cmd->obj.backingStore.ptr.gmrId = SVGA_GMR_FRAMEBUFFER;
cmd->obj.backingStore.ptr.offset = 0;
cmd->obj.backingStore.pitch = mode->hdisplay * 4;
 
vmw_fifo_commit(dev_priv, fifo_size);
148,6 → 153,8
 
sou->defined = true;
 
LEAVE();
 
return 0;
}
 
437,6 → 444,8
struct drm_encoder *encoder;
struct drm_crtc *crtc;
 
ENTER();
 
sou = kzalloc(sizeof(*sou), GFP_KERNEL);
if (!sou)
return -ENOMEM;
471,7 → 480,7
drm_object_attach_property(&connector->base,
dev->mode_config.dirty_info_property,
1);
 
LEAVE();
return 0;
}
 
572,3 → 581,164
dev_priv->sou_priv->implicit_fb =
vmw_framebuffer_to_vfb(sou->base.crtc.fb);
}
 
#include "bitmap.h"
 
typedef struct
{
kobj_t header;
 
uint32_t *data;
uint32_t hot_x;
uint32_t hot_y;
 
struct list_head list;
// struct drm_i915_gem_object *cobj;
}cursor_t;
 
 
struct tag_display
{
int x;
int y;
int width;
int height;
int bpp;
int vrefresh;
int pitch;
int lfb;
 
int supported_modes;
struct drm_device *ddev;
struct drm_connector *connector;
struct drm_crtc *crtc;
 
struct list_head cursors;
 
cursor_t *cursor;
int (*init_cursor)(cursor_t*);
cursor_t* (__stdcall *select_cursor)(cursor_t*);
void (*show_cursor)(int show);
void (__stdcall *move_cursor)(cursor_t *cursor, int x, int y);
void (__stdcall *restore_cursor)(int x, int y);
void (*disable_mouse)(void);
u32 mask_seqno;
u32 check_mouse;
u32 check_m_pixel;
u32 dirty;
void (*update)(void);
};
 
extern struct drm_device *main_device;
 
bool set_mode(struct drm_device *dev, struct drm_connector *connector,
videomode_t *reqmode, bool strict)
{
struct drm_display_mode *mode = NULL, *tmpmode;
struct vmw_private *dev_priv = vmw_priv(main_device);
struct vmw_screen_object_unit *sou;
display_t *os_display;
 
bool ret = false;
 
ENTER();
 
// dbgprintf("width %d height %d vrefresh %d\n",
// reqmode->width, reqmode->height, reqmode->freq);
 
list_for_each_entry(tmpmode, &connector->modes, head)
{
if( (drm_mode_width(tmpmode) == reqmode->width) &&
(drm_mode_height(tmpmode) == 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( (drm_mode_width(tmpmode) == reqmode->width) &&
(drm_mode_height(tmpmode) == 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];
const char *con_name;
const char *enc_name;
 
encoder = connector->encoder;
crtc = encoder->crtc;
 
 
// fb = list_first_entry(&dev->mode_config.fb_kernel_list,
// struct drm_framebuffer, filp_head);
 
// memcpy(con_edid, connector->edid_blob_ptr->data, 128);
 
// dbgprintf("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)));
 
con_name = drm_get_connector_name(connector);
enc_name = drm_get_encoder_name(encoder);
 
dbgprintf("set mode %d %d connector %s encoder %s\n",
mode->hdisplay, mode->vdisplay, con_name, enc_name);
 
os_display = GetDisplay();
 
#if 0
sou = vmw_crtc_to_sou(crtc);
sou->defined = true;
 
ret = vmw_sou_fifo_destroy(dev_priv, sou);
if (unlikely(ret != 0))
return ret;
 
ret = vmw_sou_fifo_create(dev_priv, sou, 0, 0, mode);
 
#else /* sledgehammer */
 
vmw_write(dev_priv,SVGA_REG_WIDTH, mode->hdisplay);
vmw_write(dev_priv,SVGA_REG_HEIGHT, mode->vdisplay);
vmw_write(dev_priv,SVGA_REG_BITS_PER_PIXEL, 32);
ret = 0;
#endif
if (ret == 0)
{
os_display->width = mode->hdisplay;
os_display->height = mode->vdisplay;
os_display->pitch = mode->hdisplay*4;
os_display->vrefresh = drm_mode_vrefresh(mode);
 
sysSetScreen(os_display->width, os_display->height, os_display->pitch);
 
dbgprintf("new mode %d x %d pitch %d\n",
os_display->width, os_display->height, os_display->pitch);
}
else
DRM_ERROR("failed to set mode %d_%d on crtc %p\n",
os_display->width, os_display->height, crtc);
}
 
LEAVE();
return ret;
};
/drivers/video/drm/vmwgfx/vmwgfx_ttm_glue.c
92,7 → 92,6
 
LEAVE();
return 0;
 
out_no_bo:
drm_global_item_unref(&dev_priv->mem_global_ref);
return ret;