Merge branch 'kms-merge' of git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/linux-2.6-kgdb

* 'kms-merge' of git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/linux-2.6-kgdb:
  kgdb,docs: Update the kgdb docs to include kms
  drm_fb_helper: Preserve capability to use atomic kms
  i915: when kgdb is active display compression should be off
  drm/i915: use new fb debug hooks
  drm: add KGDB/KDB support
  fb: add hooks to handle KDB enter/exit
  kgdboc: Add call backs to allow kernel mode switching
  vt,console,kdb: automatically set kdb LINES variable
  vt,console,kdb: implement atomic console enter/leave functions

7 files changed, 301 insertions, 2 deletions

diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 7cdb6ee569cd..4a9eb3044e52 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -104,6 +104,7 @@
 #include <linux/io.h>
 #include <asm/system.h>
 #include <linux/uaccess.h>
+#include <linux/kdb.h>
 
 #define MAX_NR_CON_DRIVER 16
 
@@ -187,10 +188,15 @@ static DECLARE_WORK(console_work, console_callback);
  * fg_console is the current virtual console,
  * last_console is the last used one,
  * want_console is the console we want to switch to,
+ * saved_* variants are for save/restore around kernel debugger enter/leave
  */
 int fg_console;
 int last_console;
 int want_console = -1;
+int saved_fg_console;
+int saved_last_console;
+int saved_want_console;
+int saved_vc_mode;
 
 /*
  * For each existing display, we have a pointer to console currently visible
@@ -3414,6 +3420,78 @@ int con_is_bound(const struct consw *csw)
 EXPORT_SYMBOL(con_is_bound);
 
 /**
+ * con_debug_enter - prepare the console for the kernel debugger
+ * @sw: console driver
+ *
+ * Called when the console is taken over by the kernel debugger, this
+ * function needs to save the current console state, then put the console
+ * into a state suitable for the kernel debugger.
+ *
+ * RETURNS:
+ * Zero on success, nonzero if a failure occurred when trying to prepare
+ * the console for the debugger.
+ */
+int con_debug_enter(struct vc_data *vc)
+{
+        int ret = 0;
+
+        saved_fg_console = fg_console;
+        saved_last_console = last_console;
+        saved_want_console = want_console;
+        saved_vc_mode = vc->vc_mode;
+        vc->vc_mode = KD_TEXT;
+        console_blanked = 0;
+        if (vc->vc_sw->con_debug_enter)
+                ret = vc->vc_sw->con_debug_enter(vc);
+#ifdef CONFIG_KGDB_KDB
+        /* Set the initial LINES variable if it is not already set */
+        if (vc->vc_rows < 999) {
+                int linecount;
+                char lns[4];
+                const char *setargs[3] = {
+                        "set",
+                        "LINES",
+                        lns,
+                };
+                if (kdbgetintenv(setargs[0], &linecount)) {
+                        snprintf(lns, 4, "%i", vc->vc_rows);
+                        kdb_set(2, setargs);
+                }
+        }
+#endif /* CONFIG_KGDB_KDB */
+        return ret;
+}
+EXPORT_SYMBOL_GPL(con_debug_enter);
+
+/**
+ * con_debug_leave - restore console state
+ * @sw: console driver
+ *
+ * Restore the console state to what it was before the kernel debugger
+ * was invoked.
+ *
+ * RETURNS:
+ * Zero on success, nonzero if a failure occurred when trying to restore
+ * the console.
+ */
+int con_debug_leave(void)
+{
+        struct vc_data *vc;
+        int ret = 0;
+
+        fg_console = saved_fg_console;
+        last_console = saved_last_console;
+        want_console = saved_want_console;
+        vc_cons[fg_console].d->vc_mode = saved_vc_mode;
+
+        vc = vc_cons[fg_console].d;
+        if (vc->vc_sw->con_debug_leave)
+                ret = vc->vc_sw->con_debug_leave(vc);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(con_debug_leave);
+
+/**
  * register_con_driver - register console driver to console layer
  * @csw: console driver
  * @first: the first console to take over, minimum value is 0
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index 719662034bbf..de82e201d682 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -241,6 +241,80 @@ static int drm_fb_helper_parse_command_line(struct drm_fb_helper *fb_helper)
         return 0;
 }
 
+int drm_fb_helper_debug_enter(struct fb_info *info)
+{
+        struct drm_fb_helper *helper = info->par;
+        struct drm_crtc_helper_funcs *funcs;
+        int i;
+
+        if (list_empty(&kernel_fb_helper_list))
+                return false;
+
+        list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
+                for (i = 0; i < helper->crtc_count; i++) {
+                        struct drm_mode_set *mode_set =
+                                &helper->crtc_info[i].mode_set;
+
+                        if (!mode_set->crtc->enabled)
+                                continue;
+
+                        funcs = mode_set->crtc->helper_private;
+                        funcs->mode_set_base_atomic(mode_set->crtc,
+                                                    mode_set->fb,
+                                                    mode_set->x,
+                                                    mode_set->y);
+
+                }
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(drm_fb_helper_debug_enter);
+
+/* Find the real fb for a given fb helper CRTC */
+static struct drm_framebuffer *drm_mode_config_fb(struct drm_crtc *crtc)
+{
+        struct drm_device *dev = crtc->dev;
+        struct drm_crtc *c;
+
+        list_for_each_entry(c, &dev->mode_config.crtc_list, head) {
+                if (crtc->base.id == c->base.id)
+                        return c->fb;
+        }
+
+        return NULL;
+}
+
+int drm_fb_helper_debug_leave(struct fb_info *info)
+{
+        struct drm_fb_helper *helper = info->par;
+        struct drm_crtc *crtc;
+        struct drm_crtc_helper_funcs *funcs;
+        struct drm_framebuffer *fb;
+        int i;
+
+        for (i = 0; i < helper->crtc_count; i++) {
+                struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set;
+                crtc = mode_set->crtc;
+                funcs = crtc->helper_private;
+                fb = drm_mode_config_fb(crtc);
+
+                if (!crtc->enabled)
+                        continue;
+
+                if (!fb) {
+                        DRM_ERROR("no fb to restore??\n");
+                        continue;
+                }
+
+                funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x,
+                                            crtc->y);
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(drm_fb_helper_debug_leave);
+
 bool drm_fb_helper_force_kernel_mode(void)
 {
         int i = 0;
@@ -611,7 +685,7 @@ int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
         struct drm_framebuffer *fb = fb_helper->fb;
         int depth;
 
-        if (var->pixclock != 0)
+        if (var->pixclock != 0 || in_dbg_master())
                 return -EINVAL;
 
         /* Need to resize the fb object !!! */
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 5e21b3119824..714bf539918b 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -975,7 +975,10 @@ void
 intel_wait_for_vblank(struct drm_device *dev)
 {
         /* Wait for 20ms, i.e. one cycle at 50hz. */
-        msleep(20);
+        if (in_dbg_master())
+                mdelay(20); /* The kernel debugger cannot call msleep() */
+        else
+                msleep(20);
 }
 
 /* Parameters have changed, update FBC info */
@@ -1248,6 +1251,10 @@ static void intel_update_fbc(struct drm_crtc *crtc,
                 goto out_disable;
         }
 
+        /* If the kernel debugger is active, always disable compression */
+        if (in_dbg_master())
+                goto out_disable;
+
         if (intel_fbc_enabled(dev)) {
                 /* We can re-enable it in this case, but need to update pitch */
                 if ((fb->pitch > dev_priv->cfb_pitch) ||
@@ -1314,6 +1321,98 @@ intel_pin_and_fence_fb_obj(struct drm_device *dev, struct drm_gem_object *obj)
         return 0;
 }
 
+/* Assume fb object is pinned & idle & fenced and just update base pointers */
+static int
+intel_pipe_set_base_atomic(struct drm_crtc *crtc, struct drm_framebuffer *fb,
+                           int x, int y)
+{
+        struct drm_device *dev = crtc->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        struct intel_framebuffer *intel_fb;
+        struct drm_i915_gem_object *obj_priv;
+        struct drm_gem_object *obj;
+        int plane = intel_crtc->plane;
+        unsigned long Start, Offset;
+        int dspbase = (plane == 0 ? DSPAADDR : DSPBADDR);
+        int dspsurf = (plane == 0 ? DSPASURF : DSPBSURF);
+        int dspstride = (plane == 0) ? DSPASTRIDE : DSPBSTRIDE;
+        int dsptileoff = (plane == 0 ? DSPATILEOFF : DSPBTILEOFF);
+        int dspcntr_reg = (plane == 0) ? DSPACNTR : DSPBCNTR;
+        u32 dspcntr;
+
+        switch (plane) {
+        case 0:
+        case 1:
+                break;
+        default:
+                DRM_ERROR("Can't update plane %d in SAREA\n", plane);
+                return -EINVAL;
+        }
+
+        intel_fb = to_intel_framebuffer(fb);
+        obj = intel_fb->obj;
+        obj_priv = to_intel_bo(obj);
+
+        dspcntr = I915_READ(dspcntr_reg);
+        /* Mask out pixel format bits in case we change it */
+        dspcntr &= ~DISPPLANE_PIXFORMAT_MASK;
+        switch (fb->bits_per_pixel) {
+        case 8:
+                dspcntr |= DISPPLANE_8BPP;
+                break;
+        case 16:
+                if (fb->depth == 15)
+                        dspcntr |= DISPPLANE_15_16BPP;
+                else
+                        dspcntr |= DISPPLANE_16BPP;
+                break;
+        case 24:
+        case 32:
+                dspcntr |= DISPPLANE_32BPP_NO_ALPHA;
+                break;
+        default:
+                DRM_ERROR("Unknown color depth\n");
+                return -EINVAL;
+        }
+        if (IS_I965G(dev)) {
+                if (obj_priv->tiling_mode != I915_TILING_NONE)
+                        dspcntr |= DISPPLANE_TILED;
+                else
+                        dspcntr &= ~DISPPLANE_TILED;
+        }
+
+        if (IS_IRONLAKE(dev))
+                /* must disable */
+                dspcntr |= DISPPLANE_TRICKLE_FEED_DISABLE;
+
+        I915_WRITE(dspcntr_reg, dspcntr);
+
+        Start = obj_priv->gtt_offset;
+        Offset = y * fb->pitch + x * (fb->bits_per_pixel / 8);
+
+        DRM_DEBUG("Writing base %08lX %08lX %d %d\n", Start, Offset, x, y);
+        I915_WRITE(dspstride, fb->pitch);
+        if (IS_I965G(dev)) {
+                I915_WRITE(dspbase, Offset);
+                I915_READ(dspbase);
+                I915_WRITE(dspsurf, Start);
+                I915_READ(dspsurf);
+                I915_WRITE(dsptileoff, (y << 16) | x);
+        } else {
+                I915_WRITE(dspbase, Start + Offset);
+                I915_READ(dspbase);
+        }
+
+        if ((IS_I965G(dev) || plane == 0))
+                intel_update_fbc(crtc, &crtc->mode);
+
+        intel_wait_for_vblank(dev);
+        intel_increase_pllclock(crtc, true);
+
+        return 0;
+}
+
 static int
 intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
                     struct drm_framebuffer *old_fb)
@@ -4814,6 +4913,7 @@ static const struct drm_crtc_helper_funcs intel_helper_funcs = {
         .mode_fixup = intel_crtc_mode_fixup,
         .mode_set = intel_crtc_mode_set,
         .mode_set_base = intel_pipe_set_base,
+        .mode_set_base_atomic = intel_pipe_set_base_atomic,
         .prepare = intel_crtc_prepare,
         .commit = intel_crtc_commit,
         .load_lut = intel_crtc_load_lut,
diff --git a/drivers/gpu/drm/i915/intel_fb.c b/drivers/gpu/drm/i915/intel_fb.c
index 3e18c9e7729b..54acd8b534df 100644
--- a/drivers/gpu/drm/i915/intel_fb.c
+++ b/drivers/gpu/drm/i915/intel_fb.c
@@ -61,6 +61,8 @@ static struct fb_ops intelfb_ops = {
         .fb_pan_display = drm_fb_helper_pan_display,
         .fb_blank = drm_fb_helper_blank,
         .fb_setcmap = drm_fb_helper_setcmap,
+        .fb_debug_enter = drm_fb_helper_debug_enter,
+        .fb_debug_leave = drm_fb_helper_debug_leave,
 };
 
 static int intelfb_create(struct intel_fbdev *ifbdev,
diff --git a/drivers/serial/kgdboc.c b/drivers/serial/kgdboc.c
index a9a94ae72349..39f9a1adaa75 100644
--- a/drivers/serial/kgdboc.c
+++ b/drivers/serial/kgdboc.c
@@ -17,6 +17,7 @@
 #include <linux/kdb.h>
 #include <linux/tty.h>
 #include <linux/console.h>
+#include <linux/vt_kern.h>
 
 #define MAX_CONFIG_LEN          40
 
@@ -31,6 +32,7 @@ static struct kparam_string kps = {
         .maxlen                 = MAX_CONFIG_LEN,
 };
 
+static int kgdboc_use_kms;  /* 1 if we use kernel mode switching */
 static struct tty_driver        *kgdb_tty_driver;
 static int                      kgdb_tty_line;
 
@@ -104,6 +106,12 @@ static int configure_kgdboc(void)
         kgdboc_io_ops.is_console = 0;
         kgdb_tty_driver = NULL;
 
+        kgdboc_use_kms = 0;
+        if (strncmp(cptr, "kms,", 4) == 0) {
+                cptr += 4;
+                kgdboc_use_kms = 1;
+        }
+
         if (kgdboc_register_kbd(&cptr))
                 goto do_register;
 
@@ -201,8 +209,14 @@ static int param_set_kgdboc_var(const char *kmessage, struct kernel_param *kp)
         return configure_kgdboc();
 }
 
+static int dbg_restore_graphics;
+
 static void kgdboc_pre_exp_handler(void)
 {
+        if (!dbg_restore_graphics && kgdboc_use_kms) {
+                dbg_restore_graphics = 1;
+                con_debug_enter(vc_cons[fg_console].d);
+        }
         /* Increment the module count when the debugger is active */
         if (!kgdb_connected)
                 try_module_get(THIS_MODULE);
@@ -213,6 +227,10 @@ static void kgdboc_post_exp_handler(void)
         /* decrement the module count when the debugger detaches */
         if (!kgdb_connected)
                 module_put(THIS_MODULE);
+        if (kgdboc_use_kms && dbg_restore_graphics) {
+                dbg_restore_graphics = 0;
+                con_debug_leave();
+        }
 }
 
 static struct kgdb_io kgdboc_io_ops = {
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index b0a3fa00706d..3b3f5749af92 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -2342,6 +2342,30 @@ static int fbcon_blank(struct vc_data *vc, int blank, int mode_switch)
         return 0;
 }
 
+static int fbcon_debug_enter(struct vc_data *vc)
+{
+        struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
+        struct fbcon_ops *ops = info->fbcon_par;
+
+        ops->save_graphics = ops->graphics;
+        ops->graphics = 0;
+        if (info->fbops->fb_debug_enter)
+                info->fbops->fb_debug_enter(info);
+        fbcon_set_palette(vc, color_table);
+        return 0;
+}
+
+static int fbcon_debug_leave(struct vc_data *vc)
+{
+        struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
+        struct fbcon_ops *ops = info->fbcon_par;
+
+        ops->graphics = ops->save_graphics;
+        if (info->fbops->fb_debug_leave)
+                info->fbops->fb_debug_leave(info);
+        return 0;
+}
+
 static int fbcon_get_font(struct vc_data *vc, struct console_font *font)
 {
         u8 *fontdata = vc->vc_font.data;
@@ -3276,6 +3300,8 @@ static const struct consw fb_con = {
         .con_screen_pos         = fbcon_screen_pos,
         .con_getxy              = fbcon_getxy,
         .con_resize             = fbcon_resize,
+        .con_debug_enter        = fbcon_debug_enter,
+        .con_debug_leave        = fbcon_debug_leave,
 };
 
 static struct notifier_block fbcon_event_notifier = {
diff --git a/drivers/video/console/fbcon.h b/drivers/video/console/fbcon.h
index 89a346880ec0..6bd2e0c7f209 100644
--- a/drivers/video/console/fbcon.h
+++ b/drivers/video/console/fbcon.h
@@ -74,6 +74,7 @@ struct fbcon_ops {
         int    cursor_reset;
         int    blank_state;
         int    graphics;
+        int    save_graphics; /* for debug enter/leave */
         int    flags;
         int    rotate;
         int    cur_rotate;