console: Move scrollback data into its own struct

This refactoring is in preparation for persistent scrollback
support for VGA console.

Signed-off-by: Manuel Schölling <manuel.schoelling@gmx.de>
Reviewed-by: Andrey Utkin <andrey_utkin@fastmail.com>
Tested-by: Andrey Utkin <andrey_utkin@fastmail.com>
Tested-by: Adam Borowski <kilobyte@angband.pl>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index c22a56232b7c0fa0d7542fd4a77db3ca8871f516..48b97648d4af84165bbce3555d0365ec44946caa 100644 (file)
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -162,31 +162,34 @@ static inline void vga_set_mem_top(struct vc_data *c)
 
 #ifdef CONFIG_VGACON_SOFT_SCROLLBACK
 /* software scrollback */
-static void *vgacon_scrollback;
-static int vgacon_scrollback_tail;
-static int vgacon_scrollback_size;
-static int vgacon_scrollback_rows;
-static int vgacon_scrollback_cnt;
-static int vgacon_scrollback_cur;
-static int vgacon_scrollback_save;
-static int vgacon_scrollback_restore;
+static struct vgacon_scrollback_info {
+       void *data;
+       int tail;
+       int size;
+       int rows;
+       int cnt;
+       int cur;
+       int save;
+       int restore;
+} vgacon_scrollback;
 
 static void vgacon_scrollback_init(int pitch)
 {
        int rows = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024/pitch;
 
-       if (vgacon_scrollback) {
-               vgacon_scrollback_cnt  = 0;
-               vgacon_scrollback_tail = 0;
-               vgacon_scrollback_cur  = 0;
-               vgacon_scrollback_rows = rows - 1;
-               vgacon_scrollback_size = rows * pitch;
+       if (vgacon_scrollback.data) {
+               vgacon_scrollback.cnt  = 0;
+               vgacon_scrollback.tail = 0;
+               vgacon_scrollback.cur  = 0;
+               vgacon_scrollback.rows = rows - 1;
+               vgacon_scrollback.size = rows * pitch;
        }
 }
 
 static void vgacon_scrollback_startup(void)
 {
-       vgacon_scrollback = kcalloc(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE, 1024, GFP_NOWAIT);
+       vgacon_scrollback.data = kcalloc(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE,
+               1024, GFP_NOWAIT);
        vgacon_scrollback_init(vga_video_num_columns * 2);
 }
 
@@ -194,38 +197,38 @@ static void vgacon_scrollback_update(struct vc_data *c, int t, int count)
 {
        void *p;
 
-       if (!vgacon_scrollback_size || c->vc_num != fg_console)
+       if (!vgacon_scrollback.size || c->vc_num != fg_console)
                return;
 
        p = (void *) (c->vc_origin + t * c->vc_size_row);
 
        while (count--) {
-               scr_memcpyw(vgacon_scrollback + vgacon_scrollback_tail,
+               scr_memcpyw(vgacon_scrollback.data + vgacon_scrollback.tail,
                            p, c->vc_size_row);
-               vgacon_scrollback_cnt++;
+               vgacon_scrollback.cnt++;
                p += c->vc_size_row;
-               vgacon_scrollback_tail += c->vc_size_row;
+               vgacon_scrollback.tail += c->vc_size_row;
 
-               if (vgacon_scrollback_tail >= vgacon_scrollback_size)
-                       vgacon_scrollback_tail = 0;
+               if (vgacon_scrollback.tail >= vgacon_scrollback.size)
+                       vgacon_scrollback.tail = 0;
 
-               if (vgacon_scrollback_cnt > vgacon_scrollback_rows)
-                       vgacon_scrollback_cnt = vgacon_scrollback_rows;
+               if (vgacon_scrollback.cnt > vgacon_scrollback.rows)
+                       vgacon_scrollback.cnt = vgacon_scrollback.rows;
 
-               vgacon_scrollback_cur = vgacon_scrollback_cnt;
+               vgacon_scrollback.cur = vgacon_scrollback.cnt;
        }
 }
 
 static void vgacon_restore_screen(struct vc_data *c)
 {
-       vgacon_scrollback_save = 0;
+       vgacon_scrollback.save = 0;
 
-       if (!vga_is_gfx && !vgacon_scrollback_restore) {
+       if (!vga_is_gfx && !vgacon_scrollback.restore) {
                scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
                            c->vc_screenbuf_size > vga_vram_size ?
                            vga_vram_size : c->vc_screenbuf_size);
-               vgacon_scrollback_restore = 1;
-               vgacon_scrollback_cur = vgacon_scrollback_cnt;
+               vgacon_scrollback.restore = 1;
+               vgacon_scrollback.cur = vgacon_scrollback.cnt;
        }
 }
 
@@ -239,41 +242,41 @@ static void vgacon_scrolldelta(struct vc_data *c, int lines)
                return;
        }
 
-       if (!vgacon_scrollback)
+       if (!vgacon_scrollback.data)
                return;
 
-       if (!vgacon_scrollback_save) {
+       if (!vgacon_scrollback.save) {
                vgacon_cursor(c, CM_ERASE);
                vgacon_save_screen(c);
-               vgacon_scrollback_save = 1;
+               vgacon_scrollback.save = 1;
        }
 
-       vgacon_scrollback_restore = 0;
-       start = vgacon_scrollback_cur + lines;
+       vgacon_scrollback.restore = 0;
+       start = vgacon_scrollback.cur + lines;
        end = start + abs(lines);
 
        if (start < 0)
                start = 0;
 
-       if (start > vgacon_scrollback_cnt)
-               start = vgacon_scrollback_cnt;
+       if (start > vgacon_scrollback.cnt)
+               start = vgacon_scrollback.cnt;
 
        if (end < 0)
                end = 0;
 
-       if (end > vgacon_scrollback_cnt)
-               end = vgacon_scrollback_cnt;
+       if (end > vgacon_scrollback.cnt)
+               end = vgacon_scrollback.cnt;
 
-       vgacon_scrollback_cur = start;
+       vgacon_scrollback.cur = start;
        count = end - start;
-       soff = vgacon_scrollback_tail - ((vgacon_scrollback_cnt - end) *
+       soff = vgacon_scrollback.tail - ((vgacon_scrollback.cnt - end) *
                                         c->vc_size_row);
        soff -= count * c->vc_size_row;
 
        if (soff < 0)
-               soff += vgacon_scrollback_size;
+               soff += vgacon_scrollback.size;
 
-       count = vgacon_scrollback_cnt - start;
+       count = vgacon_scrollback.cnt - start;
 
        if (count > c->vc_rows)
                count = c->vc_rows;
@@ -287,13 +290,13 @@ static void vgacon_scrolldelta(struct vc_data *c, int lines)
 
                count *= c->vc_size_row;
                /* how much memory to end of buffer left? */
-               copysize = min(count, vgacon_scrollback_size - soff);
-               scr_memcpyw(d, vgacon_scrollback + soff, copysize);
+               copysize = min(count, vgacon_scrollback.size - soff);
+               scr_memcpyw(d, vgacon_scrollback.data + soff, copysize);
                d += copysize;
                count -= copysize;
 
                if (count) {
-                       scr_memcpyw(d, vgacon_scrollback, count);
+                       scr_memcpyw(d, vgacon_scrollback.data, count);
                        d += count;
                }