5 files changed, 844 insertions, 0 deletions

diff --git a/drivers/auxdisplay/Kconfig b/drivers/auxdisplay/Kconfig
new file mode 100644
index 000000000000..0300e7f54cc4
--- /dev/null
+++ b/drivers/auxdisplay/Kconfig
@@ -0,0 +1,109 @@
+#
+# For a description of the syntax of this configuration file,
+# see Documentation/kbuild/kconfig-language.txt.
+#
+# Auxiliary display drivers configuration.
+#
+
+menu "Auxiliary Display support"
+
+config KS0108
+        tristate "KS0108 LCD Controller"
+        depends on PARPORT_PC
+        default n
+        ---help---
+          If you have a LCD controlled by one or more KS0108
+          controllers, say Y. You will need also another more specific
+          driver for your LCD.
+
+          Depends on Parallel Port support. If you say Y at
+          parport, you will be able to compile this as a module (M)
+          and built-in as well (Y).
+
+          To compile this as a module, choose M here:
+          the module will be called ks0108.
+
+          If unsure, say N.
+
+config KS0108_PORT
+        hex "Parallel port where the LCD is connected"
+        depends on KS0108
+        default 0x378
+        ---help---
+          The address of the parallel port where the LCD is connected.
+
+          The first  standard parallel port address is 0x378.
+          The second standard parallel port address is 0x278.
+          The third  standard parallel port address is 0x3BC.
+
+          You can specify a different address if you need.
+
+          If you don't know what I'm talking about, load the parport module,
+          and execute "dmesg" or "cat /proc/ioports". You can see there how
+          many parallel ports are present and which address each one has.
+
+          Usually you only need to use 0x378.
+
+          If you compile this as a module, you can still override this
+          using the module parameters.
+
+config KS0108_DELAY
+        int "Delay between each control writing (microseconds)"
+        depends on KS0108
+        default "2"
+        ---help---
+          Amount of time the ks0108 should wait between each control write
+          to the parallel port.
+
+          If your driver seems to miss random writings, increment this.
+
+          If you don't know what I'm talking about, ignore it.
+
+          If you compile this as a module, you can still override this
+          value using the module parameters.
+
+config CFAG12864B
+        tristate "CFAG12864B LCD"
+        depends on X86
+        depends on FB
+        depends on KS0108
+        default n
+        ---help---
+          If you have a Crystalfontz 128x64 2-color LCD, cfag12864b Series,
+          say Y. You also need the ks0108 LCD Controller driver.
+
+          For help about how to wire your LCD to the parallel port,
+          check Documentation/auxdisplay/cfag12864b
+
+          Depends on the x86 arch and the framebuffer support.
+
+          The LCD framebuffer driver can be attached to a console.
+          It will work fine. However, you can't attach it to the fbdev driver
+          of the xorg server.
+
+          To compile this as a module, choose M here:
+          the modules will be called cfag12864b and cfag12864bfb.
+
+          If unsure, say N.
+
+config CFAG12864B_RATE
+       int "Refresh rate (hertz)"
+        depends on CFAG12864B
+        default "20"
+        ---help---
+          Refresh rate of the LCD.
+
+          As the LCD is not memory mapped, the driver has to make the work by
+          software. This means you should be careful setting this value higher.
+          If your CPUs are really slow or you feel the system is slowed down,
+          decrease the value.
+
+          Be careful modifying this value to a very high value:
+          You can freeze the computer, or the LCD maybe can't draw as fast as you
+          are requesting.
+
+          If you don't know what I'm talking about, ignore it.
+
+          If you compile this as a module, you can still override this
+          value using the module parameters.
+endmenu
diff --git a/drivers/auxdisplay/Makefile b/drivers/auxdisplay/Makefile
new file mode 100644
index 000000000000..8a8936a468b9
--- /dev/null
+++ b/drivers/auxdisplay/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for the kernel auxiliary displays device drivers.
+#
+
+obj-$(CONFIG_KS0108)            += ks0108.o
+obj-$(CONFIG_CFAG12864B)        += cfag12864b.o cfag12864bfb.o
diff --git a/drivers/auxdisplay/cfag12864b.c b/drivers/auxdisplay/cfag12864b.c
new file mode 100644
index 000000000000..889583dfc1a6
--- /dev/null
+++ b/drivers/auxdisplay/cfag12864b.c
@@ -0,0 +1,383 @@
+/*
+ *    Filename: cfag12864b.c
+ *     Version: 0.1.0
+ * Description: cfag12864b LCD driver
+ *     License: GPLv2
+ *     Depends: ks0108
+ *
+ *      Author: Copyright (C) Miguel Ojeda Sandonis <maxextreme@gmail.com>
+ *        Date: 2006-10-31
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/cdev.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/jiffies.h>
+#include <linux/mutex.h>
+#include <linux/uaccess.h>
+#include <linux/vmalloc.h>
+#include <linux/workqueue.h>
+#include <linux/ks0108.h>
+#include <linux/cfag12864b.h>
+
+
+#define CFAG12864B_NAME "cfag12864b"
+
+/*
+ * Module Parameters
+ */
+
+static unsigned int cfag12864b_rate = CONFIG_CFAG12864B_RATE;
+module_param(cfag12864b_rate, uint, S_IRUGO);
+MODULE_PARM_DESC(cfag12864b_rate,
+        "Refresh rate (hertzs)");
+
+unsigned int cfag12864b_getrate(void)
+{
+        return cfag12864b_rate;
+}
+
+/*
+ * cfag12864b Commands
+ *
+ *      E = Enable signal
+ *              Everytime E switch from low to high,
+ *              cfag12864b/ks0108 reads the command/data.
+ *
+ *      CS1 = First ks0108controller.
+ *              If high, the first ks0108 controller receives commands/data.
+ *
+ *      CS2 = Second ks0108 controller
+ *              If high, the second ks0108 controller receives commands/data.
+ *
+ *      DI = Data/Instruction
+ *              If low, cfag12864b will expect commands.
+ *              If high, cfag12864b will expect data.
+ *
+ */
+
+#define bit(n) (((unsigned char)1)<<(n))
+
+#define CFAG12864B_BIT_E        (0)
+#define CFAG12864B_BIT_CS1      (2)
+#define CFAG12864B_BIT_CS2      (1)
+#define CFAG12864B_BIT_DI       (3)
+
+static unsigned char cfag12864b_state;
+
+static void cfag12864b_set(void)
+{
+        ks0108_writecontrol(cfag12864b_state);
+}
+
+static void cfag12864b_setbit(unsigned char state, unsigned char n)
+{
+        if (state)
+                cfag12864b_state |= bit(n);
+        else
+                cfag12864b_state &= ~bit(n);
+}
+
+static void cfag12864b_e(unsigned char state)
+{
+        cfag12864b_setbit(state, CFAG12864B_BIT_E);
+        cfag12864b_set();
+}
+
+static void cfag12864b_cs1(unsigned char state)
+{
+        cfag12864b_setbit(state, CFAG12864B_BIT_CS1);
+}
+
+static void cfag12864b_cs2(unsigned char state)
+{
+        cfag12864b_setbit(state, CFAG12864B_BIT_CS2);
+}
+
+static void cfag12864b_di(unsigned char state)
+{
+        cfag12864b_setbit(state, CFAG12864B_BIT_DI);
+}
+
+static void cfag12864b_setcontrollers(unsigned char first,
+        unsigned char second)
+{
+        if (first)
+                cfag12864b_cs1(0);
+        else
+                cfag12864b_cs1(1);
+
+        if (second)
+                cfag12864b_cs2(0);
+        else
+                cfag12864b_cs2(1);
+}
+
+static void cfag12864b_controller(unsigned char which)
+{
+        if (which == 0)
+                cfag12864b_setcontrollers(1, 0);
+        else if (which == 1)
+                cfag12864b_setcontrollers(0, 1);
+}
+
+static void cfag12864b_displaystate(unsigned char state)
+{
+        cfag12864b_di(0);
+        cfag12864b_e(1);
+        ks0108_displaystate(state);
+        cfag12864b_e(0);
+}
+
+static void cfag12864b_address(unsigned char address)
+{
+        cfag12864b_di(0);
+        cfag12864b_e(1);
+        ks0108_address(address);
+        cfag12864b_e(0);
+}
+
+static void cfag12864b_page(unsigned char page)
+{
+        cfag12864b_di(0);
+        cfag12864b_e(1);
+        ks0108_page(page);
+        cfag12864b_e(0);
+}
+
+static void cfag12864b_startline(unsigned char startline)
+{
+        cfag12864b_di(0);
+        cfag12864b_e(1);
+        ks0108_startline(startline);
+        cfag12864b_e(0);
+}
+
+static void cfag12864b_writebyte(unsigned char byte)
+{
+        cfag12864b_di(1);
+        cfag12864b_e(1);
+        ks0108_writedata(byte);
+        cfag12864b_e(0);
+}
+
+static void cfag12864b_nop(void)
+{
+        cfag12864b_startline(0);
+}
+
+/*
+ * cfag12864b Internal Commands
+ */
+
+static void cfag12864b_on(void)
+{
+        cfag12864b_setcontrollers(1, 1);
+        cfag12864b_displaystate(1);
+}
+
+static void cfag12864b_off(void)
+{
+        cfag12864b_setcontrollers(1, 1);
+        cfag12864b_displaystate(0);
+}
+
+static void cfag12864b_clear(void)
+{
+        unsigned char i, j;
+
+        cfag12864b_setcontrollers(1, 1);
+        for (i = 0; i < CFAG12864B_PAGES; i++) {
+                cfag12864b_page(i);
+                cfag12864b_address(0);
+                for (j = 0; j < CFAG12864B_ADDRESSES; j++)
+                        cfag12864b_writebyte(0);
+        }
+}
+
+/*
+ * Update work
+ */
+
+unsigned char *cfag12864b_buffer;
+static unsigned char *cfag12864b_cache;
+static DEFINE_MUTEX(cfag12864b_mutex);
+static unsigned char cfag12864b_updating;
+static void cfag12864b_update(struct work_struct *delayed_work);
+static struct workqueue_struct *cfag12864b_workqueue;
+static DECLARE_DELAYED_WORK(cfag12864b_work, cfag12864b_update);
+
+static void cfag12864b_queue(void)
+{
+        queue_delayed_work(cfag12864b_workqueue, &cfag12864b_work,
+                HZ / cfag12864b_rate);
+}
+
+unsigned char cfag12864b_enable(void)
+{
+        unsigned char ret;
+
+        mutex_lock(&cfag12864b_mutex);
+
+        if (!cfag12864b_updating) {
+                cfag12864b_updating = 1;
+                cfag12864b_queue();
+                ret = 0;
+        } else
+                ret = 1;
+
+        mutex_unlock(&cfag12864b_mutex);
+
+        return ret;
+}
+
+void cfag12864b_disable(void)
+{
+        mutex_lock(&cfag12864b_mutex);
+
+        if (cfag12864b_updating) {
+                cfag12864b_updating = 0;
+                cancel_delayed_work(&cfag12864b_work);
+                flush_workqueue(cfag12864b_workqueue);
+        }
+
+        mutex_unlock(&cfag12864b_mutex);
+}
+
+unsigned char cfag12864b_isenabled(void)
+{
+        return cfag12864b_updating;
+}
+
+static void cfag12864b_update(struct work_struct *work)
+{
+        unsigned char c;
+        unsigned short i, j, k, b;
+
+        if (memcmp(cfag12864b_cache, cfag12864b_buffer, CFAG12864B_SIZE)) {
+                for (i = 0; i < CFAG12864B_CONTROLLERS; i++) {
+                        cfag12864b_controller(i);
+                        cfag12864b_nop();
+                        for (j = 0; j < CFAG12864B_PAGES; j++) {
+                                cfag12864b_page(j);
+                                cfag12864b_nop();
+                                cfag12864b_address(0);
+                                cfag12864b_nop();
+                                for (k = 0; k < CFAG12864B_ADDRESSES; k++) {
+                                        for (c = 0, b = 0; b < 8; b++)
+                                                if (cfag12864b_buffer
+                                                        [i * CFAG12864B_ADDRESSES / 8
+                                                        + k / 8 + (j * 8 + b) *
+                                                        CFAG12864B_WIDTH / 8]
+                                                        & bit(k % 8))
+                                                        c |= bit(b);
+                                        cfag12864b_writebyte(c);
+                                }
+                        }
+                }
+
+                memcpy(cfag12864b_cache, cfag12864b_buffer, CFAG12864B_SIZE);
+        }
+
+        if (cfag12864b_updating)
+                cfag12864b_queue();
+}
+
+/*
+ * cfag12864b Exported Symbols
+ */
+
+EXPORT_SYMBOL_GPL(cfag12864b_buffer);
+EXPORT_SYMBOL_GPL(cfag12864b_getrate);
+EXPORT_SYMBOL_GPL(cfag12864b_enable);
+EXPORT_SYMBOL_GPL(cfag12864b_disable);
+EXPORT_SYMBOL_GPL(cfag12864b_isenabled);
+
+/*
+ * Module Init & Exit
+ */
+
+static int __init cfag12864b_init(void)
+{
+        int ret = -EINVAL;
+
+        if (PAGE_SIZE < CFAG12864B_SIZE) {
+                printk(KERN_ERR CFAG12864B_NAME ": ERROR: "
+                        "page size (%i) < cfag12864b size (%i)\n",
+                        (unsigned int)PAGE_SIZE, CFAG12864B_SIZE);
+                ret = -ENOMEM;
+                goto none;
+        }
+
+        cfag12864b_buffer = (unsigned char *) __get_free_page(GFP_KERNEL);
+        if (cfag12864b_buffer == NULL) {
+                printk(KERN_ERR CFAG12864B_NAME ": ERROR: "
+                        "can't get a free page\n");
+                ret = -ENOMEM;
+                goto none;
+        }
+
+        cfag12864b_cache = kmalloc(sizeof(unsigned char) *
+                CFAG12864B_SIZE, GFP_KERNEL);
+        if (cfag12864b_buffer == NULL) {
+                printk(KERN_ERR CFAG12864B_NAME ": ERROR: "
+                        "can't alloc cache buffer (%i bytes)\n",
+                        CFAG12864B_SIZE);
+                ret = -ENOMEM;
+                goto bufferalloced;
+        }
+
+        cfag12864b_workqueue = create_singlethread_workqueue(CFAG12864B_NAME);
+        if (cfag12864b_workqueue == NULL)
+                goto cachealloced;
+
+        memset(cfag12864b_buffer, 0, CFAG12864B_SIZE);
+
+        cfag12864b_clear();
+        cfag12864b_on();
+
+        return 0;
+
+cachealloced:
+        kfree(cfag12864b_cache);
+
+bufferalloced:
+        free_page((unsigned long) cfag12864b_buffer);
+
+none:
+        return ret;
+}
+
+static void __exit cfag12864b_exit(void)
+{
+        cfag12864b_disable();
+        cfag12864b_off();
+        destroy_workqueue(cfag12864b_workqueue);
+        kfree(cfag12864b_cache);
+        free_page((unsigned long) cfag12864b_buffer);
+}
+
+module_init(cfag12864b_init);
+module_exit(cfag12864b_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Miguel Ojeda Sandonis <maxextreme@gmail.com>");
+MODULE_DESCRIPTION("cfag12864b LCD driver");
diff --git a/drivers/auxdisplay/cfag12864bfb.c b/drivers/auxdisplay/cfag12864bfb.c
new file mode 100644
index 000000000000..94765e78315f
--- /dev/null
+++ b/drivers/auxdisplay/cfag12864bfb.c
@@ -0,0 +1,180 @@
+/*
+ *    Filename: cfag12864bfb.c
+ *     Version: 0.1.0
+ * Description: cfag12864b LCD framebuffer driver
+ *     License: GPLv2
+ *     Depends: cfag12864b
+ *
+ *      Author: Copyright (C) Miguel Ojeda Sandonis <maxextreme@gmail.com>
+ *        Date: 2006-10-31
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/fb.h>
+#include <linux/mm.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/uaccess.h>
+#include <linux/cfag12864b.h>
+
+#define CFAG12864BFB_NAME "cfag12864bfb"
+
+static struct fb_fix_screeninfo cfag12864bfb_fix __initdata = {
+        .id = "cfag12864b",
+        .type = FB_TYPE_PACKED_PIXELS,
+        .visual = FB_VISUAL_MONO10,
+        .xpanstep = 0,
+        .ypanstep = 0,
+        .ywrapstep = 0,
+        .line_length = CFAG12864B_WIDTH / 8,
+        .accel = FB_ACCEL_NONE,
+};
+
+static struct fb_var_screeninfo cfag12864bfb_var __initdata = {
+        .xres = CFAG12864B_WIDTH,
+        .yres = CFAG12864B_HEIGHT,
+        .xres_virtual = CFAG12864B_WIDTH,
+        .yres_virtual = CFAG12864B_HEIGHT,
+        .bits_per_pixel = 1,
+        .red = { 0, 1, 0 },
+        .green = { 0, 1, 0 },
+        .blue = { 0, 1, 0 },
+        .left_margin = 0,
+        .right_margin = 0,
+        .upper_margin = 0,
+        .lower_margin = 0,
+        .vmode = FB_VMODE_NONINTERLACED,
+};
+
+static int cfag12864bfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
+{
+        return vm_insert_page(vma, vma->vm_start,
+                virt_to_page(cfag12864b_buffer));
+}
+
+static struct fb_ops cfag12864bfb_ops = {
+        .owner = THIS_MODULE,
+        .fb_fillrect = cfb_fillrect,
+        .fb_copyarea = cfb_copyarea,
+        .fb_imageblit = cfb_imageblit,
+        .fb_mmap = cfag12864bfb_mmap,
+};
+
+static int __init cfag12864bfb_probe(struct platform_device *device)
+{
+        int ret = -EINVAL;
+        struct fb_info *info = framebuffer_alloc(0, &device->dev);
+
+        if (!info)
+                goto none;
+
+        info->screen_base = (char __iomem *) cfag12864b_buffer;
+        info->screen_size = CFAG12864B_SIZE;
+        info->fbops = &cfag12864bfb_ops;
+        info->fix = cfag12864bfb_fix;
+        info->var = cfag12864bfb_var;
+        info->pseudo_palette = NULL;
+        info->par = NULL;
+        info->flags = FBINFO_FLAG_DEFAULT;
+
+        if (register_framebuffer(info) < 0)
+                goto fballoced;
+
+        platform_set_drvdata(device, info);
+
+        printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
+                info->fix.id);
+
+        return 0;
+
+fballoced:
+        framebuffer_release(info);
+
+none:
+        return ret;
+}
+
+static int cfag12864bfb_remove(struct platform_device *device)
+{
+        struct fb_info *info = platform_get_drvdata(device);
+
+        if (info) {
+                unregister_framebuffer(info);
+                framebuffer_release(info);
+        }
+
+        return 0;
+}
+
+static struct platform_driver cfag12864bfb_driver = {
+        .probe  = cfag12864bfb_probe,
+        .remove = cfag12864bfb_remove,
+        .driver = {
+                .name   = CFAG12864BFB_NAME,
+        },
+};
+
+static struct platform_device *cfag12864bfb_device;
+
+static int __init cfag12864bfb_init(void)
+{
+        int ret;
+
+        if (cfag12864b_enable()) {
+                printk(KERN_ERR CFAG12864BFB_NAME ": ERROR: "
+                        "can't enable cfag12864b refreshing (being used)\n");
+                return -ENODEV;
+        }
+
+        ret = platform_driver_register(&cfag12864bfb_driver);
+
+        if (!ret) {
+                cfag12864bfb_device =
+                        platform_device_alloc(CFAG12864BFB_NAME, 0);
+
+                if (cfag12864bfb_device)
+                        ret = platform_device_add(cfag12864bfb_device);
+                else
+                        ret = -ENOMEM;
+
+                if (ret) {
+                        platform_device_put(cfag12864bfb_device);
+                        platform_driver_unregister(&cfag12864bfb_driver);
+                }
+        }
+
+        return ret;
+}
+
+static void __exit cfag12864bfb_exit(void)
+{
+        platform_device_unregister(cfag12864bfb_device);
+        platform_driver_unregister(&cfag12864bfb_driver);
+        cfag12864b_disable();
+}
+
+module_init(cfag12864bfb_init);
+module_exit(cfag12864bfb_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Miguel Ojeda Sandonis <maxextreme@gmail.com>");
+MODULE_DESCRIPTION("cfag12864b LCD framebuffer driver");
diff --git a/drivers/auxdisplay/ks0108.c b/drivers/auxdisplay/ks0108.c
new file mode 100644
index 000000000000..a637575b9106
--- /dev/null
+++ b/drivers/auxdisplay/ks0108.c
@@ -0,0 +1,166 @@
+/*
+ *    Filename: ks0108.c
+ *     Version: 0.1.0
+ * Description: ks0108 LCD Controller driver
+ *     License: GPLv2
+ *     Depends: parport
+ *
+ *      Author: Copyright (C) Miguel Ojeda Sandonis <maxextreme@gmail.com>
+ *        Date: 2006-10-31
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/fs.h>
+#include <linux/io.h>
+#include <linux/parport.h>
+#include <linux/uaccess.h>
+#include <linux/ks0108.h>
+
+#define KS0108_NAME "ks0108"
+
+/*
+ * Module Parameters
+ */
+
+static unsigned int ks0108_port = CONFIG_KS0108_PORT;
+module_param(ks0108_port, uint, S_IRUGO);
+MODULE_PARM_DESC(ks0108_port, "Parallel port where the LCD is connected");
+
+static unsigned int ks0108_delay = CONFIG_KS0108_DELAY;
+module_param(ks0108_delay, uint, S_IRUGO);
+MODULE_PARM_DESC(ks0108_delay, "Delay between each control writing (microseconds)");
+
+/*
+ * Device
+ */
+
+static struct parport *ks0108_parport;
+static struct pardevice *ks0108_pardevice;
+
+/*
+ * ks0108 Exported Commands (don't lock)
+ *
+ *   You _should_ lock in the top driver: This functions _should not_
+ *   get race conditions in any way. Locking for each byte here would be
+ *   so slow and useless.
+ *
+ *   There are not bit definitions because they are not flags,
+ *   just arbitrary combinations defined by the documentation for each
+ *   function in the ks0108 LCD controller. If you want to know what means
+ *   a specific combination, look at the function's name.
+ *
+ *   The ks0108_writecontrol bits need to be reverted ^(0,1,3) because
+ *   the parallel port also revert them using a "not" logic gate.
+ */
+
+#define bit(n) (((unsigned char)1)<<(n))
+
+void ks0108_writedata(unsigned char byte)
+{
+        parport_write_data(ks0108_parport, byte);
+}
+
+void ks0108_writecontrol(unsigned char byte)
+{
+        udelay(ks0108_delay);
+        parport_write_control(ks0108_parport, byte ^ (bit(0) | bit(1) | bit(3)));
+}
+
+void ks0108_displaystate(unsigned char state)
+{
+        ks0108_writedata((state ? bit(0) : 0) | bit(1) | bit(2) | bit(3) | bit(4) | bit(5));
+}
+
+void ks0108_startline(unsigned char startline)
+{
+        ks0108_writedata(min(startline,(unsigned char)63) | bit(6) | bit(7));
+}
+
+void ks0108_address(unsigned char address)
+{
+        ks0108_writedata(min(address,(unsigned char)63) | bit(6));
+}
+
+void ks0108_page(unsigned char page)
+{
+        ks0108_writedata(min(page,(unsigned char)7) | bit(3) | bit(4) | bit(5) | bit(7));
+}
+
+EXPORT_SYMBOL_GPL(ks0108_writedata);
+EXPORT_SYMBOL_GPL(ks0108_writecontrol);
+EXPORT_SYMBOL_GPL(ks0108_displaystate);
+EXPORT_SYMBOL_GPL(ks0108_startline);
+EXPORT_SYMBOL_GPL(ks0108_address);
+EXPORT_SYMBOL_GPL(ks0108_page);
+
+/*
+ * Module Init & Exit
+ */
+
+static int __init ks0108_init(void)
+{
+        int result;
+        int ret = -EINVAL;
+
+        ks0108_parport = parport_find_base(ks0108_port);
+        if (ks0108_parport == NULL) {
+                printk(KERN_ERR KS0108_NAME ": ERROR: "
+                        "parport didn't find %i port\n", ks0108_port);
+                goto none;
+        }
+
+        ks0108_pardevice = parport_register_device(ks0108_parport, KS0108_NAME,
+                NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL);
+        if (ks0108_pardevice == NULL) {
+                printk(KERN_ERR KS0108_NAME ": ERROR: "
+                        "parport didn't register new device\n");
+                goto none;
+        }
+
+        result = parport_claim(ks0108_pardevice);
+        if (result != 0) {
+                printk(KERN_ERR KS0108_NAME ": ERROR: "
+                        "can't claim %i parport, maybe in use\n", ks0108_port);
+                ret = result;
+                goto registered;
+        }
+
+        return 0;
+
+registered:
+        parport_unregister_device(ks0108_pardevice);
+
+none:
+        return ret;
+}
+
+static void __exit ks0108_exit(void)
+{
+        parport_release(ks0108_pardevice);
+        parport_unregister_device(ks0108_pardevice);
+}
+
+module_init(ks0108_init);
+module_exit(ks0108_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Miguel Ojeda Sandonis <maxextreme@gmail.com>");
+MODULE_DESCRIPTION("ks0108 LCD Controller driver");
+