Changeset 59640 in vbox for trunk/src/VBox/Additions

Timestamp:

Feb 12, 2016 8:29:09 AM (9 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

105490

Message:

bugref:8087: Additions/x11: support non-root X server: more adjustment of the DRM driver back to kernel coding style and removal of some dead code.

Location:

trunk/src/VBox/Additions/linux/drm

Files:

• vbox_drv.h (modified) (1 diff)
• vbox_fb.c (modified) (22 diffs)
• vbox_main.c (modified) (9 diffs)
• vbox_mode.c (modified) (9 diffs)

trunk/src/VBox/Additions/linux/drm/vbox_drv.h

@@ -196 +196 @@
 #endif
 
-void vbox_enable_vbva(struct vbox_private *vbox, unsigned crtc_id);
+void vbox_enable_accel(struct vbox_private *vbox, unsigned crtc_id);
 void vbox_enable_caps(struct vbox_private *vbox);
 

trunk/src/VBox/Additions/linux/drm/vbox_fb.c

@@ -77 +77 @@
  * themselves.  Update: we also do the same for reporting hot-plug support. I
  * wonder whether we should allow it at all on the console. */
-static int VBoxSetPar(struct fb_info *pInfo)
-{
-    struct vbox_fbdev *pVFBDev = pInfo->par;
+static int vbox_set_par(struct fb_info *info)
+{
+    struct vbox_fbdev *fbdev = info->par;
     struct drm_device *dev;
-    struct vbox_private *pVBox;
+    struct vbox_private *vbox;
     unsigned i;
 
     LogFunc(("vboxvideo: %d\n", __LINE__));
-    dev = pVFBDev->helper.dev;
-    pVBox = dev->dev_private;
+    dev = fbdev->helper.dev;
+    vbox = dev->dev_private;
     vbox_refresh_modes(dev);
-    for (i = 0; i < pVBox->num_crtcs; ++i)
-        VBoxVBVADisable(&pVBox->vbva_info[i], &pVBox->submit_info, i);
-    VBoxHGSMISendCapsInfo(&pVBox->submit_info, 0);
-    return drm_fb_helper_set_par(pInfo);
+    for (i = 0; i < vbox->num_crtcs; ++i)
+        VBoxVBVADisable(&vbox->vbva_info[i], &vbox->submit_info, i);
+    VBoxHGSMISendCapsInfo(&vbox->submit_info, 0);
+    return drm_fb_helper_set_par(info);
 }
 
@@ -97 +97 @@
  * Tell the host about dirty rectangles to update.
  */
-static void vbox_dirty_update(struct vbox_fbdev *afbdev,
+static void vbox_dirty_update(struct vbox_fbdev *fbdev,
                  int x, int y, int width, int height)
 {
-    struct drm_device *dev = afbdev->helper.dev;
+    struct drm_device *dev = fbdev->helper.dev;
     struct vbox_private *vbox = dev->dev_private;
     int i;
@@ -107 +107 @@
     struct vbox_bo *bo;
     int src_offset, dst_offset;
-    int bpp = (afbdev->afb.base.bits_per_pixel + 7)/8;
+    int bpp = (fbdev->afb.base.bits_per_pixel + 7)/8;
     int ret = -EBUSY;
     bool unmap = false;
@@ -116 +116 @@
 
     LogFunc(("vboxvideo: %d\n", __LINE__));
-    obj = afbdev->afb.obj;
+    obj = fbdev->afb.obj;
     bo = gem_to_vbox_bo(obj);
 
@@ -137 +137 @@
     spin_lock_irqsave(&vbox->dev_lock, flags);
 
-    if (afbdev->y1 < y)
-        y = afbdev->y1;
-    if (afbdev->y2 > y2)
-        y2 = afbdev->y2;
-    if (afbdev->x1 < x)
-        x = afbdev->x1;
-    if (afbdev->x2 > x2)
-        x2 = afbdev->x2;
+    if (fbdev->y1 < y)
+        y = fbdev->y1;
+    if (fbdev->y2 > y2)
+        y2 = fbdev->y2;
+    if (fbdev->x1 < x)
+        x = fbdev->x1;
+    if (fbdev->x2 > x2)
+        x2 = fbdev->x2;
 
     if (store_for_later) {
-        afbdev->x1 = x;
-        afbdev->x2 = x2;
-        afbdev->y1 = y;
-        afbdev->y2 = y2;
+        fbdev->x1 = x;
+        fbdev->x2 = x2;
+        fbdev->y1 = y;
+        fbdev->y2 = y2;
         spin_unlock_irqrestore(&vbox->dev_lock, flags);
         LogFunc(("vboxvideo: %d\n", __LINE__));
@@ -156 +156 @@
     }
 
-    afbdev->x1 = afbdev->y1 = INT_MAX;
-    afbdev->x2 = afbdev->y2 = 0;
+    fbdev->x1 = fbdev->y1 = INT_MAX;
+    fbdev->x2 = fbdev->y2 = 0;
     spin_unlock_irqrestore(&vbox->dev_lock, flags);
 
@@ -171 +171 @@
     for (i = y; i <= y2; i++) {
         /* assume equal stride for now */
-        src_offset = dst_offset = i * afbdev->afb.base.pitches[0] + (x * bpp);
-        memcpy_toio(bo->kmap.virtual + src_offset, (char *)afbdev->sysram + src_offset, (x2 - x + 1) * bpp);
+        src_offset = dst_offset = i * fbdev->afb.base.pitches[0] + (x * bpp);
+        memcpy_toio(bo->kmap.virtual + src_offset, (char *)fbdev->sysram + src_offset, (x2 - x + 1) * bpp);
     }
     /* Not sure why the original code subtracted 1 here, but I will keep it that
@@ -180 +180 @@
     rect.y1 = y;
     rect.y2 = y2 + 1;
-    vbox_framebuffer_dirty_rectangles(&afbdev->afb.base, &rect, 1);
-    LogFunc(("vboxvideo: %d, bo->kmap.virtual=%p, afbdev->sysram=%p, x=%d, y=%d, x2=%d, y2=%d, unmap=%RTbool\n",
-             __LINE__, bo->kmap.virtual, afbdev->sysram, (int)x, (int)y, (int)x2, (int)y2, unmap));
+    vbox_framebuffer_dirty_rectangles(&fbdev->afb.base, &rect, 1);
+    LogFunc(("vboxvideo: %d, bo->kmap.virtual=%p, fbdev->sysram=%p, x=%d, y=%d, x2=%d, y2=%d, unmap=%RTbool\n",
+             __LINE__, bo->kmap.virtual, fbdev->sysram, (int)x, (int)y, (int)x2, (int)y2, unmap));
     if (unmap)
         ttm_bo_kunmap(&bo->kmap);
@@ -192 +192 @@
              const struct fb_fillrect *rect)
 {
-    struct vbox_fbdev *afbdev = info->par;
+    struct vbox_fbdev *fbdev = info->par;
     LogFunc(("vboxvideo: %d\n", __LINE__));
     sys_fillrect(info, rect);
-    vbox_dirty_update(afbdev, rect->dx, rect->dy, rect->width,
+    vbox_dirty_update(fbdev, rect->dx, rect->dy, rect->width,
              rect->height);
 }
@@ -202 +202 @@
              const struct fb_copyarea *area)
 {
-    struct vbox_fbdev *afbdev = info->par;
+    struct vbox_fbdev *fbdev = info->par;
     LogFunc(("vboxvideo: %d\n", __LINE__));
     sys_copyarea(info, area);
-    vbox_dirty_update(afbdev, area->dx, area->dy, area->width,
+    vbox_dirty_update(fbdev, area->dx, area->dy, area->width,
              area->height);
 }
@@ -212 +212 @@
               const struct fb_image *image)
 {
-    struct vbox_fbdev *afbdev = info->par;
+    struct vbox_fbdev *fbdev = info->par;
     LogFunc(("vboxvideo: %d\n", __LINE__));
     sys_imageblit(info, image);
-    vbox_dirty_update(afbdev, image->dx, image->dy, image->width,
+    vbox_dirty_update(fbdev, image->dx, image->dy, image->width,
              image->height);
 }
@@ -222 +222 @@
     .owner = THIS_MODULE,
     .fb_check_var = drm_fb_helper_check_var,
-    .fb_set_par = VBoxSetPar,
+    .fb_set_par = vbox_set_par,
     .fb_fillrect = vbox_fillrect,
     .fb_copyarea = vbox_copyarea,
@@ -233 +233 @@
 };
 
-static int vboxfb_create_object(struct vbox_fbdev *afbdev,
+static int vboxfb_create_object(struct vbox_fbdev *fbdev,
                    struct DRM_MODE_FB_CMD *mode_cmd,
                    struct drm_gem_object **gobj_p)
 {
-    struct drm_device *dev = afbdev->helper.dev;
+    struct drm_device *dev = fbdev->helper.dev;
     u32 bpp, depth;
     u32 size;
@@ -264 +264 @@
             struct drm_fb_helper_surface_size *sizes)
 {
-    struct vbox_fbdev *afbdev =
+    struct vbox_fbdev *fbdev =
             container_of(helper, struct vbox_fbdev, helper);
-    struct drm_device *dev = afbdev->helper.dev;
+    struct drm_device *dev = fbdev->helper.dev;
     struct DRM_MODE_FB_CMD mode_cmd;
     struct drm_framebuffer *fb;
@@ -293 +293 @@
     size = pitch * mode_cmd.height;
 
-    ret = vboxfb_create_object(afbdev, &mode_cmd, &gobj);
+    ret = vboxfb_create_object(fbdev, &mode_cmd, &gobj);
     if (ret) {
         DRM_ERROR("failed to create fbcon backing object %d\n", ret);
@@ -309 +309 @@
         goto out;
     }
-    info->par = afbdev;
-
-    ret = vbox_framebuffer_init(dev, &afbdev->afb, &mode_cmd, gobj);
+    info->par = fbdev;
+
+    ret = vbox_framebuffer_init(dev, &fbdev->afb, &mode_cmd, gobj);
     if (ret)
         goto out;
 
-    afbdev->sysram = sysram;
-    afbdev->size = size;
-
-    fb = &afbdev->afb.base;
-    afbdev->helper.fb = fb;
-    afbdev->helper.fbdev = info;
+    fbdev->sysram = sysram;
+    fbdev->size = size;
+
+    fb = &fbdev->afb.base;
+    fbdev->helper.fb = fb;
+    fbdev->helper.fbdev = info;
 
     strcpy(info->fix.id, "vboxdrmfb");
@@ -347 +347 @@
 
     drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth);
-    drm_fb_helper_fill_var(info, &afbdev->helper, sizes->fb_width, sizes->fb_height);
+    drm_fb_helper_fill_var(info, &fbdev->helper, sizes->fb_width, sizes->fb_height);
 
     info->screen_base = sysram;
@@ -385 +385 @@
 
 static void vbox_fbdev_destroy(struct drm_device *dev,
-                  struct vbox_fbdev *afbdev)
+                  struct vbox_fbdev *fbdev)
 {
     struct fb_info *info;
-    struct vbox_framebuffer *afb = &afbdev->afb;
-    LogFunc(("vboxvideo: %d\n", __LINE__));
-    if (afbdev->helper.fbdev) {
-        info = afbdev->helper.fbdev;
+    struct vbox_framebuffer *afb = &fbdev->afb;
+    LogFunc(("vboxvideo: %d\n", __LINE__));
+    if (fbdev->helper.fbdev) {
+        info = fbdev->helper.fbdev;
         unregister_framebuffer(info);
         if (info->cmap.len)
@@ -402 +402 @@
         afb->obj = NULL;
     }
-    drm_fb_helper_fini(&afbdev->helper);
-
-    vfree(afbdev->sysram);
+    drm_fb_helper_fini(&fbdev->helper);
+
+    vfree(fbdev->sysram);
     drm_framebuffer_unregister_private(&afb->base);
     drm_framebuffer_cleanup(&afb->base);
@@ -413 +413 @@
 {
     struct vbox_private *vbox = dev->dev_private;
-    struct vbox_fbdev *afbdev;
+    struct vbox_fbdev *fbdev;
     int ret;
 
     LogFunc(("vboxvideo: %d\n", __LINE__));
-    afbdev = kzalloc(sizeof(struct vbox_fbdev), GFP_KERNEL);
-    if (!afbdev)
+    fbdev = kzalloc(sizeof(struct vbox_fbdev), GFP_KERNEL);
+    if (!fbdev)
         return -ENOMEM;
 
-    vbox->fbdev = afbdev;
+    vbox->fbdev = fbdev;
 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0)
-    afbdev->helper.funcs = &vbox_fb_helper_funcs;
+    fbdev->helper.funcs = &vbox_fb_helper_funcs;
 #else
-    drm_fb_helper_prepare(dev, &afbdev->helper, &vbox_fb_helper_funcs);
+    drm_fb_helper_prepare(dev, &fbdev->helper, &vbox_fb_helper_funcs);
 #endif
-    ret = drm_fb_helper_init(dev, &afbdev->helper, vbox->num_crtcs, vbox->num_crtcs);
+    ret = drm_fb_helper_init(dev, &fbdev->helper, vbox->num_crtcs, vbox->num_crtcs);
     if (ret)
         goto free;
 
-    ret = drm_fb_helper_single_add_all_connectors(&afbdev->helper);
+    ret = drm_fb_helper_single_add_all_connectors(&fbdev->helper);
     if (ret)
         goto fini;
@@ -438 +438 @@
     drm_helper_disable_unused_functions(dev);
 
-    ret = drm_fb_helper_initial_config(&afbdev->helper, 32);
+    ret = drm_fb_helper_initial_config(&fbdev->helper, 32);
     if (ret)
         goto fini;
@@ -445 +445 @@
     return 0;
 fini:
-    drm_fb_helper_fini(&afbdev->helper);
+    drm_fb_helper_fini(&fbdev->helper);
 free:
-    kfree(afbdev);
+    kfree(fbdev);
     LogFunc(("vboxvideo: %d, ret=%d\n", __LINE__, ret));
     return ret;

trunk/src/VBox/Additions/linux/drm/vbox_main.c

@@ -66 +66 @@
 }
 
-void vbox_enable_vbva(struct vbox_private *vbox, unsigned crtc_id)
-{
-    struct VBVABUFFER *pVBVA = vbox->vbva_info[crtc_id].pVBVA;
-
-    if (pVBVA == NULL)     {
+void vbox_enable_accel(struct vbox_private *vbox, unsigned crtc_id)
+{
+    struct VBVABUFFER *vbva = vbox->vbva_info[crtc_id].pVBVA;
+
+    if (vbva == NULL) {
         LogFunc(("vboxvideo: enabling VBVA.\n"));
-        pVBVA = (struct VBVABUFFER *) (  ((uint8_t *)vbox->vram)
+        vbva = (struct VBVABUFFER *) (  ((uint8_t *)vbox->vram)
                                        + vbox->vram_size
                                        + crtc_id * VBVA_MIN_BUFFER_SIZE);
-        if (!VBoxVBVAEnable(&vbox->vbva_info[crtc_id], &vbox->submit_info, pVBVA, crtc_id))
+        if (!VBoxVBVAEnable(&vbox->vbva_info[crtc_id], &vbox->submit_info, vbva, crtc_id))
             AssertReleaseMsgFailed(("VBoxVBVAEnable failed - heap allocation error, very old host or driver error.\n"));
     }
@@ -101 +101 @@
     if (vbox->vbva_info[0].pVBVA == NULL) {
         for (i = 0; i < vbox->num_crtcs; ++i)
-            vbox_enable_vbva(vbox, i);
+            vbox_enable_accel(vbox, i);
         /* Assume that if the user knows to send dirty rectangle information
          * they can also handle hot-plug events. */
@@ -113 +113 @@
         {
             unsigned crtc_id = to_vbox_crtc(crtc)->crtc_id;
-            VBVACMDHDR cmdHdr;
+            VBVACMDHDR cmd_hdr;
 
             if (   CRTC_FB(crtc) != fb
@@ -123 +123 @@
                 || rects[i].y2 < crtc->y)
                 continue;
-            cmdHdr.x = (int16_t)rects[i].x1;
-            cmdHdr.y = (int16_t)rects[i].y1;
-            cmdHdr.w = (uint16_t)rects[i].x2 - rects[i].x1;
-            cmdHdr.h = (uint16_t)rects[i].y2 - rects[i].y1;
+            cmd_hdr.x = (int16_t)rects[i].x1;
+            cmd_hdr.y = (int16_t)rects[i].y1;
+            cmd_hdr.w = (uint16_t)rects[i].x2 - rects[i].x1;
+            cmd_hdr.h = (uint16_t)rects[i].y2 - rects[i].y1;
             if (VBoxVBVABufferBeginUpdate(&vbox->vbva_info[crtc_id],
                                           &vbox->submit_info))
             {
-                VBoxVBVAWrite(&vbox->vbva_info[crtc_id], &vbox->submit_info, &cmdHdr,
-                              sizeof(cmdHdr));
+                VBoxVBVAWrite(&vbox->vbva_info[crtc_id], &vbox->submit_info, &cmd_hdr,
+                              sizeof(cmd_hdr));
                 VBoxVBVABufferEndUpdate(&vbox->vbva_info[crtc_id]);
             }
@@ -212 +212 @@
 };
 
-static void disableVBVA(struct vbox_private *pVBox)
+static void vbox_accel_fini(struct vbox_private *vbox)
 {
     unsigned i;
 
-    if (pVBox->vbva_info)
+    if (vbox->vbva_info)
     {
-        for (i = 0; i < pVBox->num_crtcs; ++i)
-            VBoxVBVADisable(&pVBox->vbva_info[i], &pVBox->submit_info, i);
-        kfree(pVBox->vbva_info);
-        pVBox->vbva_info = NULL;
-    }
-}
-
-static int vbox_vbva_init(struct vbox_private *vbox)
+        for (i = 0; i < vbox->num_crtcs; ++i)
+            VBoxVBVADisable(&vbox->vbva_info[i], &vbox->submit_info, i);
+        kfree(vbox->vbva_info);
+        vbox->vbva_info = NULL;
+    }
+}
+
+static int vbox_accel_init(struct vbox_private *vbox)
 {
     unsigned i;
-    bool fRC = true;
     LogFunc(("vboxvideo: %d: vbox=%p, vbox->num_crtcs=%u, vbox->vbva_info=%p\n",
              __LINE__, vbox, (unsigned)vbox->num_crtcs, vbox->vbva_info));
@@ -250 +249 @@
 }
 
-
 /** Allocation function for the HGSMI heap and data. */
-static DECLCALLBACK(void *) hgsmiEnvAlloc(void *pvEnv, HGSMISIZE cb)
-{
-    NOREF(pvEnv);
-    return kmalloc(cb, GFP_KERNEL);
+static DECLCALLBACK(void *) alloc_hgsmi_environ(void *environ, HGSMISIZE size)
+{
+    NOREF(environ);
+    return kmalloc(size, GFP_KERNEL);
 }
 
 
 /** Free function for the HGSMI heap and data. */
-static DECLCALLBACK(void) hgsmiEnvFree(void *pvEnv, void *pv)
-{
-    NOREF(pvEnv);
-    kfree(pv);
+static DECLCALLBACK(void) free_hgsmi_environ(void *environ, void *ptr)
+{
+    NOREF(environ);
+    kfree(ptr);
 }
 
 
 /** Pointers to the HGSMI heap and data manipulation functions. */
-static HGSMIENV g_hgsmiEnv =
+static HGSMIENV hgsmi_environ =
 {
     NULL,
-    hgsmiEnvAlloc,
-    hgsmiEnvFree
+    alloc_hgsmi_environ,
+    free_hgsmi_environ
 };
 
 
 /** Do we support the 4.3 plus mode hint reporting interface? */
-static bool haveHGSMImode_hintAndCursorReportingInterface(struct vbox_private *pVBox)
-{
-    uint32_t fmode_hintReporting, fCursorReporting;
-
-    return    RT_SUCCESS(VBoxQueryConfHGSMI(&pVBox->submit_info, VBOX_VBVA_CONF32_MODE_HINT_REPORTING, &fmode_hintReporting))
-           && RT_SUCCESS(VBoxQueryConfHGSMI(&pVBox->submit_info, VBOX_VBVA_CONF32_GUEST_CURSOR_REPORTING, &fCursorReporting))
-           && fmode_hintReporting == VINF_SUCCESS
-           && fCursorReporting == VINF_SUCCESS;
+static bool have_hgsmi_mode_hints(struct vbox_private *vbox)
+{
+    uint32_t have_hints, have_cursor;
+
+    return    RT_SUCCESS(VBoxQueryConfHGSMI(&vbox->submit_info, VBOX_VBVA_CONF32_MODE_HINT_REPORTING, &have_hints))
+           && RT_SUCCESS(VBoxQueryConfHGSMI(&vbox->submit_info, VBOX_VBVA_CONF32_GUEST_CURSOR_REPORTING, &have_cursor))
+           && have_hints == VINF_SUCCESS
+           && have_cursor == VINF_SUCCESS;
 }
 
@@ -290 +288 @@
 /** Set up our heaps and data exchange buffers in VRAM before handing the rest
  *  to the memory manager. */
-static int setupAcceleration(struct vbox_private *pVBox)
-{
-    uint32_t offBase, offGuestHeap, cbGuestHeap, host_flags_offset;
-    void *pvGuestHeap;
-
-    VBoxHGSMIGetBaseMappingInfo(pVBox->full_vram_size, &offBase, NULL,
-                                &offGuestHeap, &cbGuestHeap, &host_flags_offset);
-    pvGuestHeap =   ((uint8_t *)pVBox->vram) + offBase + offGuestHeap;
-    pVBox->host_flags_offset = offBase + host_flags_offset;
-    if (RT_FAILURE(VBoxHGSMISetupGuestContext(&pVBox->submit_info, pvGuestHeap,
-                                              cbGuestHeap,
-                                              offBase + offGuestHeap,
-                                              &g_hgsmiEnv)))
+static int vbox_hw_init(struct vbox_private *vbox)
+{
+    uint32_t base_offset, guest_heap_offset, guest_heap_size, host_flags_offset;
+    void *guest_heap;
+
+    VBoxHGSMIGetBaseMappingInfo(vbox->full_vram_size, &base_offset, NULL,
+                                &guest_heap_offset, &guest_heap_size, &host_flags_offset);
+    guest_heap =   ((uint8_t *)vbox->vram) + base_offset + guest_heap_offset;
+    vbox->host_flags_offset = base_offset + host_flags_offset;
+    if (RT_FAILURE(VBoxHGSMISetupGuestContext(&vbox->submit_info, guest_heap,
+                                              guest_heap_size,
+                                              base_offset + guest_heap_offset,
+                                              &hgsmi_environ)))
         return -ENOMEM;
     /* Reduce available VRAM size to reflect the guest heap. */
-    pVBox->vram_size = offBase;
+    vbox->vram_size = base_offset;
     /* Linux drm represents monitors as a 32-bit array. */
-    pVBox->num_crtcs = RT_MIN(VBoxHGSMIGetMonitorCount(&pVBox->submit_info), 32);
-    if (!haveHGSMImode_hintAndCursorReportingInterface(pVBox))
+    vbox->num_crtcs = RT_MIN(VBoxHGSMIGetMonitorCount(&vbox->submit_info), 32);
+    if (!have_hgsmi_mode_hints(vbox))
         return -ENOTSUPP;
-    pVBox->last_mode_hints = kzalloc(sizeof(VBVAMODEHINT) * pVBox->num_crtcs, GFP_KERNEL);
-    if (!pVBox->last_mode_hints)
+    vbox->last_mode_hints = kzalloc(sizeof(VBVAMODEHINT) * vbox->num_crtcs, GFP_KERNEL);
+    if (!vbox->last_mode_hints)
         return -ENOMEM;
-    return vbox_vbva_init(pVBox);
+    return vbox_accel_init(vbox);
 }
 
@@ -343 +341 @@
     DRM_INFO("VRAM %08x\n", vbox->full_vram_size);
 
-    ret = setupAcceleration(vbox);
+    ret = vbox_hw_init(vbox);
     if (ret)
         goto out_free;
@@ -394 +392 @@
     drm_mode_config_cleanup(dev);
 
-    disableVBVA(vbox);
+    vbox_accel_fini(vbox);
     vbox_mm_fini(vbox);
     pci_iounmap(dev->pdev, vbox->vram);

trunk/src/VBox/Additions/linux/drm/vbox_mode.c

@@ -71 +71 @@
     struct vbox_crtc   *vbox_crtc = to_vbox_crtc(crtc);
     struct vbox_private *vbox;
-    int width, height, cBPP, pitch;
+    int width, height, bpp, pitch;
     unsigned crtc_id;
-    uint16_t fFlags;
+    uint16_t flags;
 
     LogFunc(("vboxvideo: %d: vbox_crtc=%p, CRTC_FB(crtc)=%p\n", __LINE__,
@@ -81 +81 @@
     height = mode->vdisplay ? mode->vdisplay : 480;
     crtc_id = vbox_crtc->crtc_id;
-    cBPP = crtc->enabled ? CRTC_FB(crtc)->bits_per_pixel : 32;
+    bpp = crtc->enabled ? CRTC_FB(crtc)->bits_per_pixel : 32;
 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 3, 0)
-    pitch = crtc->enabled ? CRTC_FB(crtc)->pitch : width * cBPP / 8;
+    pitch = crtc->enabled ? CRTC_FB(crtc)->pitch : width * bpp / 8;
 #else
-    pitch = crtc->enabled ? CRTC_FB(crtc)->pitches[0] : width * cBPP / 8;
+    pitch = crtc->enabled ? CRTC_FB(crtc)->pitches[0] : width * bpp / 8;
 #endif
     /* if (vbox_crtc->crtc_id == 0 && crtc->enabled)
-        VBoxVideoSetModeRegisters(width, height, pitch * 8 / cBPP,
+        VBoxVideoSetModeRegisters(width, height, pitch * 8 / bpp,
                                   CRTC_FB(crtc)->bits_per_pixel, 0,
                                   crtc->x, crtc->y); */
-    fFlags = VBVA_SCREEN_F_ACTIVE;
-    fFlags |= (crtc->enabled ? 0 : VBVA_SCREEN_F_DISABLED);
+    flags = VBVA_SCREEN_F_ACTIVE;
+    flags |= (crtc->enabled ? 0 : VBVA_SCREEN_F_DISABLED);
     VBoxHGSMIProcessDisplayInfo(&vbox->submit_info, vbox_crtc->crtc_id,
                                 crtc->x, crtc->y,
-                                crtc->x * cBPP / 8 + crtc->y * pitch,
+                                crtc->x * bpp / 8 + crtc->y * pitch,
                                 pitch, width, height,
-                                vbox_crtc->blanked ? 0 : cBPP, fFlags);
+                                vbox_crtc->blanked ? 0 : bpp, flags);
     VBoxHGSMIReportFlagsLocation(&vbox->submit_info, vbox->host_flags_offset);
     vbox_enable_caps(vbox);
@@ -223 +223 @@
 
         for (i = 0; i < vbox->num_crtcs; ++i)
-            vbox_enable_vbva(vbox, i);
+            vbox_enable_accel(vbox, i);
     }
     vbox_bo_unreserve(bo);
@@ -415 +415 @@
 {
     struct vbox_connector *vbox_connector = NULL;
-    struct drm_display_mode *pMode = NULL;
-    unsigned cModes = 0;
-    int widthPreferred, heightPreferred;
+    struct drm_display_mode *mode = NULL;
+    unsigned num_modes = 0;
+    int preferred_width, preferred_height;
 
     LogFunc(("vboxvideo: %d: connector=%p\n", __LINE__, connector));
     vbox_connector = to_vbox_connector(connector);
-    cModes = drm_add_modes_noedid(connector, 2560, 1600);
-    widthPreferred = vbox_connector->mode_hint.width ? vbox_connector->mode_hint.width : 1024;
-    heightPreferred = vbox_connector->mode_hint.height ? vbox_connector->mode_hint.height : 768;
-    pMode = drm_cvt_mode(connector->dev, widthPreferred, heightPreferred, 60, false,
+    num_modes = drm_add_modes_noedid(connector, 2560, 1600);
+    preferred_width = vbox_connector->mode_hint.width ? vbox_connector->mode_hint.width : 1024;
+    preferred_height = vbox_connector->mode_hint.height ? vbox_connector->mode_hint.height : 768;
+    mode = drm_cvt_mode(connector->dev, preferred_width, preferred_height, 60, false,
                          false, false);
-    if (pMode)
+    if (mode)
     {
-        pMode->type |= DRM_MODE_TYPE_PREFERRED;
-        drm_mode_probed_add(connector, pMode);
-        ++cModes;
-    }
-    return cModes;
+        mode->type |= DRM_MODE_TYPE_PREFERRED;
+        drm_mode_probed_add(connector, mode);
+        ++num_modes;
+    }
+    return num_modes;
 }
 
@@ -468 +468 @@
 }
 
-static int vbox_fill_modes(struct drm_connector *connector, uint32_t xMax, uint32_t yMax)
+static int vbox_fill_modes(struct drm_connector *connector, uint32_t max_x, uint32_t max_y)
 {
     struct vbox_connector *vbox_connector;
-    struct drm_device *pDrmDev;
-    struct drm_display_mode *pMode, *pIter;
-
-    LogFunc(("vboxvideo: %d: connector=%p, xMax=%lu, yMax = %lu\n", __LINE__,
-             connector, (unsigned long)xMax, (unsigned long)yMax));
+    struct drm_device *dev;
+    struct drm_display_mode *mode, *iterator;
+
+    LogFunc(("vboxvideo: %d: connector=%p, max_x=%lu, max_y = %lu\n", __LINE__,
+             connector, (unsigned long)max_x, (unsigned long)max_y));
     vbox_connector = to_vbox_connector(connector);
-    pDrmDev = vbox_connector->base.dev;
-    list_for_each_entry_safe(pMode, pIter, &connector->modes, head)
+    dev = vbox_connector->base.dev;
+    list_for_each_entry_safe(mode, iterator, &connector->modes, head)
     {
-        list_del(&pMode->head);
-        drm_mode_destroy(pDrmDev, pMode);
-    }
-    return drm_helper_probe_single_connector_modes(connector, xMax, yMax);
+        list_del(&mode->head);
+        drm_mode_destroy(dev, mode);
+    }
+    return drm_helper_probe_single_connector_modes(connector, max_x, max_y);
 }
 
@@ -504 +504 @@
 {
     struct vbox_connector *vbox_connector;
-    struct vbox_private *pVBox;
+    struct vbox_private *vbox;
 
     LogFunc(("vboxvideo: %d: dev=%p, pAttr=%p, psz=%s, cch=%llu\n", __LINE__,
@@ -510 +510 @@
     vbox_connector = container_of(pAttr, struct vbox_connector,
                                   sysfs_node);
-    pVBox = vbox_connector->base.dev->dev_private;
+    vbox = vbox_connector->base.dev->dev_private;
     drm_kms_helper_hotplug_event(vbox_connector->base.dev);
-    if (pVBox->fbdev)
-        drm_fb_helper_hotplug_event(&pVBox->fbdev->helper);
+    if (vbox->fbdev)
+        drm_fb_helper_hotplug_event(&vbox->fbdev->helper);
     return cch;
 }
@@ -575 +575 @@
 }
 
-#if 0
-/* allocate cursor cache and pin at start of VRAM */
-int vbox_cursor_init(struct drm_device *dev)
+int vbox_mode_init(struct drm_device *dev)
 {
     struct vbox_private *vbox = dev->dev_private;
-    int size;
-    int ret;
-    struct drm_gem_object *obj;
-    struct vbox_bo *bo;
-    uint64_t gpu_addr;
-
-    size = (AST_HWC_SIZE + AST_HWC_SIGNATURE_SIZE) * AST_DEFAULT_HWC_NUM;
-
-    ret = vbox_gem_create(dev, size, true, &obj);
-    if (ret)
-        return ret;
-    bo = gem_to_vbox_bo(obj);
-    ret = vbox_bo_reserve(bo, false);
-    if (unlikely(ret != 0))
-        goto fail;
-
-    ret = vbox_bo_pin(bo, TTM_PL_FLAG_VRAM, &gpu_addr);
-    vbox_bo_unreserve(bo);
-    if (ret)
-        goto fail;
-
-    /* kmap the object */
-    ret = ttm_bo_kmap(&bo->bo, 0, bo->bo.num_pages, &vbox->cache_kmap);
-    if (ret)
-        goto fail;
-
-    vbox->cursor_cache = obj;
-    vbox->cursor_cache_gpu_addr = gpu_addr;
-    DRM_DEBUG_KMS("pinned cursor cache at %llx\n", vbox->cursor_cache_gpu_addr);
-    return 0;
-fail:
-    return ret;
-}
-
-void vbox_cursor_fini(struct drm_device *dev)
-{
-    struct vbox_private *vbox = dev->dev_private;
-    ttm_bo_kunmap(&vbox->cache_kmap);
-    drm_gem_object_unreference_unlocked(vbox->cursor_cache);
-}
-#endif
-
-int vbox_mode_init(struct drm_device *dev)
-{
-    struct vbox_private *pVBox = dev->dev_private;
     struct drm_encoder *encoder;
     unsigned i;
     /* vbox_cursor_init(dev); */
     LogFunc(("vboxvideo: %d: dev=%p\n", __LINE__, dev));
-    for (i = 0; i < pVBox->num_crtcs; ++i)
+    for (i = 0; i < vbox->num_crtcs; ++i)
     {
         vbox_crtc_init(dev, i);
@@ -720 +673 @@
                     if (!src_isiomem)
                     {
-                        uint32_t fFlags =   VBOX_MOUSE_POINTER_VISIBLE
+                        uint32_t flags =   VBOX_MOUSE_POINTER_VISIBLE
                                           | VBOX_MOUSE_POINTER_SHAPE
                                           | VBOX_MOUSE_POINTER_ALPHA;
                         copy_cursor_image(src, dst, width, height, cbMask);
-                        rc = VBoxHGSMIUpdatePointerShape(&vbox->submit_info, fFlags,
+                        rc = VBoxHGSMIUpdatePointerShape(&vbox->submit_info, flags,
                                                          hot_x, hot_y, width,
                                                          height, dst, cbData);