From patchwork Sun Jul 15 19:04:44 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Herrmann X-Patchwork-Id: 1199341 Return-Path: X-Original-To: patchwork-linux-fbdev@patchwork.kernel.org Delivered-To: patchwork-process-083081@patchwork1.kernel.org Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by patchwork1.kernel.org (Postfix) with ESMTP id 48B413FC33 for ; Sun, 15 Jul 2012 19:06:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752088Ab2GOTGk (ORCPT ); Sun, 15 Jul 2012 15:06:40 -0400 Received: from mail-we0-f174.google.com ([74.125.82.174]:62804 "EHLO mail-we0-f174.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751651Ab2GOTFc (ORCPT ); Sun, 15 Jul 2012 15:05:32 -0400 Received: by mail-we0-f174.google.com with SMTP id x8so3536651wey.19 for ; Sun, 15 Jul 2012 12:05:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=googlemail.com; s=20120113; h=from:to:cc:subject:date:message-id:x-mailer:in-reply-to:references; bh=B1JHN90qe+SbqcquwdHJN1nDg7HvGsjNv+1O1v1DvWM=; b=FbVlYW1KzSIeAWR4oVlp8G18f9r1Fu5khms/ovPivihdyryQey6q3JPvbmV6LEvEyj L21wPYAq8e9MSFSeNG3DzOhxURMackcLd53r/NHyW0mGAh5oCRtLSmO6lbDhRmAeETGH LRGVKtfVf3KAMlMYlYl/k/s3OsOlCIdRKBL17/mCJpjRmtb67KgAnHMCtOKkUzBYe+/u AkuddNkfWlvttRzkHljpAww8STQ8O9B7IXfk45Hz3HRRd1KJ3YUvihEF1Mfqapf7QSde bT80EZzlffraxL6EZKmJElPV3BfoviAhJuGz3lXC3sCwUNOHLJv+HO4u3VjBtizgKc0q d8Qg== Received: by 10.216.196.218 with SMTP id r68mr3901048wen.122.1342379131894; Sun, 15 Jul 2012 12:05:31 -0700 (PDT) Received: from localhost.localdomain (stgt-5f71ba59.pool.mediaWays.net. [95.113.186.89]) by mx.google.com with ESMTPS id j6sm25479086wiy.4.2012.07.15.12.05.30 (version=TLSv1/SSLv3 cipher=OTHER); Sun, 15 Jul 2012 12:05:31 -0700 (PDT) From: David Herrmann To: linux-kernel@vger.kernel.org Cc: Florian Tobias Schandinat , Andrew Morton , Greg Kroah-Hartman , linux-fbdev@vger.kernel.org, linux-serial@vger.kernel.org, Alan Cox , David Herrmann Subject: [PATCH v3 09/11] fblog: register console driver Date: Sun, 15 Jul 2012 21:04:44 +0200 Message-Id: <1342379086-7583-10-git-send-email-dh.herrmann@googlemail.com> X-Mailer: git-send-email 1.7.11.2 In-Reply-To: <1342379086-7583-1-git-send-email-dh.herrmann@googlemail.com> References: <1342379086-7583-1-git-send-email-dh.herrmann@googlemail.com> Sender: linux-fbdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fbdev@vger.kernel.org We want to print the kernel log to all FBs so we need a console driver. This registers the driver on startup and writes all messages to all registered fblog instances. We cannot share a console buffer between FBs because they might have different resolutions. Therefore, we create one buffer per object. We destroy the buffer during close() so we do not waste memory if it is not used. Signed-off-by: David Herrmann --- drivers/video/console/fblog.c | 150 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 150 insertions(+) diff --git a/drivers/video/console/fblog.c b/drivers/video/console/fblog.c index 9b975bc..ae01742 100644 --- a/drivers/video/console/fblog.c +++ b/drivers/video/console/fblog.c @@ -25,11 +25,34 @@ #define pr_fmt(_fmt) KBUILD_MODNAME ": " _fmt +#include #include #include #include #include +/** + * struct fblog_buf: Console text buffer + * + * Each framebuffer has its own text buffer which contains all characters that + * are currently printed on screen. The buffers might have different sizes and + * can be resized during runtime. When the buffer content changes, we redraw the + * screen. + * + * width: Width of buffer in characters + * height: Height of buffer in characters + * lines: Array of lines + * pos_x: Cursor x-position + * pos_y: Cursor y-position + */ +struct fblog_buf { + size_t width; + size_t height; + u16 **lines; + size_t pos_x; + size_t pos_y; +}; + enum fblog_flags { FBLOG_KILLED, FBLOG_OPEN, @@ -42,6 +65,7 @@ struct fblog_fb { struct fb_info *info; struct device dev; struct mutex lock; + struct fblog_buf buf; }; static DEFINE_MUTEX(fblog_registration_lock); @@ -50,6 +74,106 @@ static bool active = 1; #define to_fblog_dev(_d) container_of(_d, struct fblog_fb, dev) +static void fblog_buf_resize(struct fblog_buf *buf, size_t width, + size_t height) +{ + u16 **lines = NULL; + size_t i, j, minw, minh; + + if (buf->height == height && buf->width == width) + return; + + if (width && height) { + lines = kzalloc(height * sizeof(char *), GFP_KERNEL); + if (!lines) + return; + + for (i = 0; i < height; ++i) { + lines[i] = kzalloc(width * sizeof(u16), GFP_KERNEL); + if (!lines[i]) { + while (i--) + kfree(lines[i]); + return; + } + } + + /* copy old lines */ + minw = min(width, buf->width); + minh = min(height, buf->height); + if (height >= buf->height) + i = 0; + else + i = buf->height - height; + + for (j = 0; j < minh; ++i, ++j) + memcpy(lines[j], buf->lines[i], minw * sizeof(u16)); + } else { + width = 0; + height = 0; + } + + for (i = 0; i < buf->height; ++i) + kfree(buf->lines[i]); + kfree(buf->lines); + + buf->lines = lines; + buf->width = width; + buf->height = height; +} + +static void fblog_buf_deinit(struct fblog_buf *buf) +{ + fblog_buf_resize(buf, 0, 0); +} + +static void fblog_buf_rotate(struct fblog_buf *buf) +{ + u16 *line; + + if (!buf->height) + return; + + line = buf->lines[0]; + memset(line, 0, sizeof(u16) * buf->width); + + memmove(buf->lines, &buf->lines[1], sizeof(char*) * (buf->height - 1)); + buf->lines[buf->height - 1] = line; +} + +static void fblog_buf_write(struct fblog_buf *buf, const char *str, size_t len) +{ + char c; + + if (!buf->height) + return; + + while (len--) { + c = *str++; + + if (c == 0) + c = '?'; + + if (c == '\n') { + buf->pos_x = 0; + if (++buf->pos_y >= buf->height) { + buf->pos_y = buf->height - 1; + fblog_buf_rotate(buf); + } + } else { + if (buf->pos_x >= buf->width) { + buf->pos_x = 0; + ++buf->pos_y; + } + if (buf->pos_y >= buf->height) { + buf->pos_y = buf->height - 1; + fblog_buf_rotate(buf); + } + + buf->lines[buf->pos_y][buf->pos_x++] = c; + } + } +} + /* * fblog_open/close() * These functions manage access to the underlying framebuffer. While opened, we @@ -64,6 +188,7 @@ static bool active = 1; static int fblog_open(struct fblog_fb *fb) { + static const char init_str[] = "Framebuffer log initialized\n"; int ret; mutex_lock(&fb->lock); @@ -88,6 +213,8 @@ static int fblog_open(struct fblog_fb *fb) goto out_unref; } + fblog_buf_resize(&fb->buf, 80, 24); + fblog_buf_write(&fb->buf, init_str, sizeof(init_str) - 1); set_bit(FBLOG_OPEN, &fb->flags); mutex_unlock(&fb->lock); return 0; @@ -110,6 +237,7 @@ static void fblog_close(struct fblog_fb *fb, bool kill_dev) fb->info->fbops->fb_release(fb->info, 0); module_put(fb->info->fbops->owner); clear_bit(FBLOG_OPEN, &fb->flags); + fblog_buf_deinit(&fb->buf); } if (kill_dev) @@ -372,6 +500,26 @@ static struct notifier_block fblog_notifier = { .notifier_call = fblog_event, }; +static void fblog_con_write(struct console *con, const char *buf, + unsigned int len) +{ + int i; + + mutex_lock(&fblog_registration_lock); + for (i = 0; i < FB_MAX; ++i) { + if (fblog_fbs[i]) { + fblog_buf_write(&fblog_fbs[i]->buf, buf, len); + } + } + mutex_unlock(&fblog_registration_lock); +} + +static struct console fblog_con_driver = { + .name = "fblog", + .write = fblog_con_write, + .flags = CON_PRINTBUFFER | CON_ENABLED, +}; + static int __init fblog_init(void) { int ret; @@ -383,6 +531,7 @@ static int __init fblog_init(void) } fblog_scan(); + register_console(&fblog_con_driver); return 0; } @@ -392,6 +541,7 @@ static void __exit fblog_exit(void) unsigned int i; struct fb_info *info; + unregister_console(&fblog_con_driver); fb_unregister_client(&fblog_notifier); /* We scan through the whole registered_fb array here instead of