linux/drivers/auxdisplay/cfag12864b.c
<<
>>
Prefs
   1/*
   2 *    Filename: cfag12864b.c
   3 *     Version: 0.1.0
   4 * Description: cfag12864b LCD driver
   5 *     License: GPLv2
   6 *     Depends: ks0108
   7 *
   8 *      Author: Copyright (C) Miguel Ojeda Sandonis
   9 *        Date: 2006-10-31
  10 *
  11 *  This program is free software; you can redistribute it and/or modify
  12 *  it under the terms of the GNU General Public License version 2 as
  13 *  published by the Free Software Foundation.
  14 *
  15 *  This program is distributed in the hope that it will be useful,
  16 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 *  GNU General Public License for more details.
  19 *
  20 *  You should have received a copy of the GNU General Public License
  21 *  along with this program; if not, write to the Free Software
  22 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23 *
  24 */
  25
  26#include <linux/init.h>
  27#include <linux/module.h>
  28#include <linux/kernel.h>
  29#include <linux/fs.h>
  30#include <linux/slab.h>
  31#include <linux/cdev.h>
  32#include <linux/delay.h>
  33#include <linux/device.h>
  34#include <linux/jiffies.h>
  35#include <linux/mutex.h>
  36#include <linux/uaccess.h>
  37#include <linux/vmalloc.h>
  38#include <linux/workqueue.h>
  39#include <linux/ks0108.h>
  40#include <linux/cfag12864b.h>
  41
  42
  43#define CFAG12864B_NAME "cfag12864b"
  44
  45/*
  46 * Module Parameters
  47 */
  48
  49static unsigned int cfag12864b_rate = CONFIG_CFAG12864B_RATE;
  50module_param(cfag12864b_rate, uint, S_IRUGO);
  51MODULE_PARM_DESC(cfag12864b_rate,
  52        "Refresh rate (hertz)");
  53
  54unsigned int cfag12864b_getrate(void)
  55{
  56        return cfag12864b_rate;
  57}
  58
  59/*
  60 * cfag12864b Commands
  61 *
  62 *      E = Enable signal
  63 *              Every time E switch from low to high,
  64 *              cfag12864b/ks0108 reads the command/data.
  65 *
  66 *      CS1 = First ks0108controller.
  67 *              If high, the first ks0108 controller receives commands/data.
  68 *
  69 *      CS2 = Second ks0108 controller
  70 *              If high, the second ks0108 controller receives commands/data.
  71 *
  72 *      DI = Data/Instruction
  73 *              If low, cfag12864b will expect commands.
  74 *              If high, cfag12864b will expect data.
  75 *
  76 */
  77
  78#define bit(n) (((unsigned char)1)<<(n))
  79
  80#define CFAG12864B_BIT_E        (0)
  81#define CFAG12864B_BIT_CS1      (2)
  82#define CFAG12864B_BIT_CS2      (1)
  83#define CFAG12864B_BIT_DI       (3)
  84
  85static unsigned char cfag12864b_state;
  86
  87static void cfag12864b_set(void)
  88{
  89        ks0108_writecontrol(cfag12864b_state);
  90}
  91
  92static void cfag12864b_setbit(unsigned char state, unsigned char n)
  93{
  94        if (state)
  95                cfag12864b_state |= bit(n);
  96        else
  97                cfag12864b_state &= ~bit(n);
  98}
  99
 100static void cfag12864b_e(unsigned char state)
 101{
 102        cfag12864b_setbit(state, CFAG12864B_BIT_E);
 103        cfag12864b_set();
 104}
 105
 106static void cfag12864b_cs1(unsigned char state)
 107{
 108        cfag12864b_setbit(state, CFAG12864B_BIT_CS1);
 109}
 110
 111static void cfag12864b_cs2(unsigned char state)
 112{
 113        cfag12864b_setbit(state, CFAG12864B_BIT_CS2);
 114}
 115
 116static void cfag12864b_di(unsigned char state)
 117{
 118        cfag12864b_setbit(state, CFAG12864B_BIT_DI);
 119}
 120
 121static void cfag12864b_setcontrollers(unsigned char first,
 122        unsigned char second)
 123{
 124        if (first)
 125                cfag12864b_cs1(0);
 126        else
 127                cfag12864b_cs1(1);
 128
 129        if (second)
 130                cfag12864b_cs2(0);
 131        else
 132                cfag12864b_cs2(1);
 133}
 134
 135static void cfag12864b_controller(unsigned char which)
 136{
 137        if (which == 0)
 138                cfag12864b_setcontrollers(1, 0);
 139        else if (which == 1)
 140                cfag12864b_setcontrollers(0, 1);
 141}
 142
 143static void cfag12864b_displaystate(unsigned char state)
 144{
 145        cfag12864b_di(0);
 146        cfag12864b_e(1);
 147        ks0108_displaystate(state);
 148        cfag12864b_e(0);
 149}
 150
 151static void cfag12864b_address(unsigned char address)
 152{
 153        cfag12864b_di(0);
 154        cfag12864b_e(1);
 155        ks0108_address(address);
 156        cfag12864b_e(0);
 157}
 158
 159static void cfag12864b_page(unsigned char page)
 160{
 161        cfag12864b_di(0);
 162        cfag12864b_e(1);
 163        ks0108_page(page);
 164        cfag12864b_e(0);
 165}
 166
 167static void cfag12864b_startline(unsigned char startline)
 168{
 169        cfag12864b_di(0);
 170        cfag12864b_e(1);
 171        ks0108_startline(startline);
 172        cfag12864b_e(0);
 173}
 174
 175static void cfag12864b_writebyte(unsigned char byte)
 176{
 177        cfag12864b_di(1);
 178        cfag12864b_e(1);
 179        ks0108_writedata(byte);
 180        cfag12864b_e(0);
 181}
 182
 183static void cfag12864b_nop(void)
 184{
 185        cfag12864b_startline(0);
 186}
 187
 188/*
 189 * cfag12864b Internal Commands
 190 */
 191
 192static void cfag12864b_on(void)
 193{
 194        cfag12864b_setcontrollers(1, 1);
 195        cfag12864b_displaystate(1);
 196}
 197
 198static void cfag12864b_off(void)
 199{
 200        cfag12864b_setcontrollers(1, 1);
 201        cfag12864b_displaystate(0);
 202}
 203
 204static void cfag12864b_clear(void)
 205{
 206        unsigned char i, j;
 207
 208        cfag12864b_setcontrollers(1, 1);
 209        for (i = 0; i < CFAG12864B_PAGES; i++) {
 210                cfag12864b_page(i);
 211                cfag12864b_address(0);
 212                for (j = 0; j < CFAG12864B_ADDRESSES; j++)
 213                        cfag12864b_writebyte(0);
 214        }
 215}
 216
 217/*
 218 * Update work
 219 */
 220
 221unsigned char *cfag12864b_buffer;
 222static unsigned char *cfag12864b_cache;
 223static DEFINE_MUTEX(cfag12864b_mutex);
 224static unsigned char cfag12864b_updating;
 225static void cfag12864b_update(struct work_struct *delayed_work);
 226static struct workqueue_struct *cfag12864b_workqueue;
 227static DECLARE_DELAYED_WORK(cfag12864b_work, cfag12864b_update);
 228
 229static void cfag12864b_queue(void)
 230{
 231        queue_delayed_work(cfag12864b_workqueue, &cfag12864b_work,
 232                HZ / cfag12864b_rate);
 233}
 234
 235unsigned char cfag12864b_enable(void)
 236{
 237        unsigned char ret;
 238
 239        mutex_lock(&cfag12864b_mutex);
 240
 241        if (!cfag12864b_updating) {
 242                cfag12864b_updating = 1;
 243                cfag12864b_queue();
 244                ret = 0;
 245        } else
 246                ret = 1;
 247
 248        mutex_unlock(&cfag12864b_mutex);
 249
 250        return ret;
 251}
 252
 253void cfag12864b_disable(void)
 254{
 255        mutex_lock(&cfag12864b_mutex);
 256
 257        if (cfag12864b_updating) {
 258                cfag12864b_updating = 0;
 259                cancel_delayed_work(&cfag12864b_work);
 260                flush_workqueue(cfag12864b_workqueue);
 261        }
 262
 263        mutex_unlock(&cfag12864b_mutex);
 264}
 265
 266unsigned char cfag12864b_isenabled(void)
 267{
 268        return cfag12864b_updating;
 269}
 270
 271static void cfag12864b_update(struct work_struct *work)
 272{
 273        unsigned char c;
 274        unsigned short i, j, k, b;
 275
 276        if (memcmp(cfag12864b_cache, cfag12864b_buffer, CFAG12864B_SIZE)) {
 277                for (i = 0; i < CFAG12864B_CONTROLLERS; i++) {
 278                        cfag12864b_controller(i);
 279                        cfag12864b_nop();
 280                        for (j = 0; j < CFAG12864B_PAGES; j++) {
 281                                cfag12864b_page(j);
 282                                cfag12864b_nop();
 283                                cfag12864b_address(0);
 284                                cfag12864b_nop();
 285                                for (k = 0; k < CFAG12864B_ADDRESSES; k++) {
 286                                        for (c = 0, b = 0; b < 8; b++)
 287                                                if (cfag12864b_buffer
 288                                                        [i * CFAG12864B_ADDRESSES / 8
 289                                                        + k / 8 + (j * 8 + b) *
 290                                                        CFAG12864B_WIDTH / 8]
 291                                                        & bit(k % 8))
 292                                                        c |= bit(b);
 293                                        cfag12864b_writebyte(c);
 294                                }
 295                        }
 296                }
 297
 298                memcpy(cfag12864b_cache, cfag12864b_buffer, CFAG12864B_SIZE);
 299        }
 300
 301        if (cfag12864b_updating)
 302                cfag12864b_queue();
 303}
 304
 305/*
 306 * cfag12864b Exported Symbols
 307 */
 308
 309EXPORT_SYMBOL_GPL(cfag12864b_buffer);
 310EXPORT_SYMBOL_GPL(cfag12864b_getrate);
 311EXPORT_SYMBOL_GPL(cfag12864b_enable);
 312EXPORT_SYMBOL_GPL(cfag12864b_disable);
 313EXPORT_SYMBOL_GPL(cfag12864b_isenabled);
 314
 315/*
 316 * Is the module inited?
 317 */
 318
 319static unsigned char cfag12864b_inited;
 320unsigned char cfag12864b_isinited(void)
 321{
 322        return cfag12864b_inited;
 323}
 324EXPORT_SYMBOL_GPL(cfag12864b_isinited);
 325
 326/*
 327 * Module Init & Exit
 328 */
 329
 330static int __init cfag12864b_init(void)
 331{
 332        int ret = -EINVAL;
 333
 334        /* ks0108_init() must be called first */
 335        if (!ks0108_isinited()) {
 336                printk(KERN_ERR CFAG12864B_NAME ": ERROR: "
 337                        "ks0108 is not initialized\n");
 338                goto none;
 339        }
 340        BUILD_BUG_ON(PAGE_SIZE < CFAG12864B_SIZE);
 341
 342        cfag12864b_buffer = (unsigned char *) get_zeroed_page(GFP_KERNEL);
 343        if (cfag12864b_buffer == NULL) {
 344                printk(KERN_ERR CFAG12864B_NAME ": ERROR: "
 345                        "can't get a free page\n");
 346                ret = -ENOMEM;
 347                goto none;
 348        }
 349
 350        cfag12864b_cache = kmalloc(sizeof(unsigned char) *
 351                CFAG12864B_SIZE, GFP_KERNEL);
 352        if (cfag12864b_cache == NULL) {
 353                printk(KERN_ERR CFAG12864B_NAME ": ERROR: "
 354                        "can't alloc cache buffer (%i bytes)\n",
 355                        CFAG12864B_SIZE);
 356                ret = -ENOMEM;
 357                goto bufferalloced;
 358        }
 359
 360        cfag12864b_workqueue = create_singlethread_workqueue(CFAG12864B_NAME);
 361        if (cfag12864b_workqueue == NULL)
 362                goto cachealloced;
 363
 364        cfag12864b_clear();
 365        cfag12864b_on();
 366
 367        cfag12864b_inited = 1;
 368        return 0;
 369
 370cachealloced:
 371        kfree(cfag12864b_cache);
 372
 373bufferalloced:
 374        free_page((unsigned long) cfag12864b_buffer);
 375
 376none:
 377        return ret;
 378}
 379
 380static void __exit cfag12864b_exit(void)
 381{
 382        cfag12864b_disable();
 383        cfag12864b_off();
 384        destroy_workqueue(cfag12864b_workqueue);
 385        kfree(cfag12864b_cache);
 386        free_page((unsigned long) cfag12864b_buffer);
 387}
 388
 389module_init(cfag12864b_init);
 390module_exit(cfag12864b_exit);
 391
 392MODULE_LICENSE("GPL v2");
 393MODULE_AUTHOR("Miguel Ojeda Sandonis <miguel.ojeda.sandonis@gmail.com>");
 394MODULE_DESCRIPTION("cfag12864b LCD driver");
 395
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.