release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/auxdisplay/cfag12864b.c

   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
  49 static unsigned int cfag12864b_rate = CONFIG_CFAG12864B_RATE;
  50 module_param(cfag12864b_rate, uint, S_IRUGO);
  51 MODULE_PARM_DESC(cfag12864b_rate,
  52         "Refresh rate (hertzs)");
  53
  54 unsigned int cfag12864b_getrate(void)
  55 {
  56         return cfag12864b_rate;
  57 }
  58
  59 /*
  60  * cfag12864b Commands
  61  *
  62  *      E = Enable signal
  63  *              Everytime 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
  85 static unsigned char cfag12864b_state;
  86
  87 static void cfag12864b_set(void)
  88 {
  89         ks0108_writecontrol(cfag12864b_state);
  90 }
  91
  92 static 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
 100 static void cfag12864b_e(unsigned char state)
 101 {
 102         cfag12864b_setbit(state, CFAG12864B_BIT_E);
 103         cfag12864b_set();
 104 }
 105
 106 static void cfag12864b_cs1(unsigned char state)
 107 {
 108         cfag12864b_setbit(state, CFAG12864B_BIT_CS1);
 109 }
 110
 111 static void cfag12864b_cs2(unsigned char state)
 112 {
 113         cfag12864b_setbit(state, CFAG12864B_BIT_CS2);
 114 }
 115
 116 static void cfag12864b_di(unsigned char state)
 117 {
 118         cfag12864b_setbit(state, CFAG12864B_BIT_DI);
 119 }
 120
 121 static 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
 135 static 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
 143 static 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
 151 static 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
 159 static 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
 167 static 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
 175 static 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
 183 static void cfag12864b_nop(void)
 184 {
 185         cfag12864b_startline(0);
 186 }
 187
 188 /*
 189  * cfag12864b Internal Commands
 190  */
 191
 192 static void cfag12864b_on(void)
 193 {
 194         cfag12864b_setcontrollers(1, 1);
 195         cfag12864b_displaystate(1);
 196 }
 197
 198 static void cfag12864b_off(void)
 199 {
 200         cfag12864b_setcontrollers(1, 1);
 201         cfag12864b_displaystate(0);
 202 }
 203
 204 static 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
 221 unsigned char *cfag12864b_buffer;
 222 static unsigned char *cfag12864b_cache;
 223 static DEFINE_MUTEX(cfag12864b_mutex);
 224 static unsigned char cfag12864b_updating;
 225 static void cfag12864b_update(struct work_struct *delayed_work);
 226 static struct workqueue_struct *cfag12864b_workqueue;
 227 static DECLARE_DELAYED_WORK(cfag12864b_work, cfag12864b_update);
 228
 229 static void cfag12864b_queue(void)
 230 {
 231         queue_delayed_work(cfag12864b_workqueue, &cfag12864b_work,
 232                 HZ / cfag12864b_rate);
 233 }
 234
 235 unsigned 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
 253 void 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
 266 unsigned char cfag12864b_isenabled(void)
 267 {
 268         return cfag12864b_updating;
 269 }
 270
 271 static 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
 309 EXPORT_SYMBOL_GPL(cfag12864b_buffer);
 310 EXPORT_SYMBOL_GPL(cfag12864b_getrate);
 311 EXPORT_SYMBOL_GPL(cfag12864b_enable);
 312 EXPORT_SYMBOL_GPL(cfag12864b_disable);
 313 EXPORT_SYMBOL_GPL(cfag12864b_isenabled);
 314
 315 /*
 316  * Is the module inited?
 317  */
 318
 319 static unsigned char cfag12864b_inited;
 320 unsigned char cfag12864b_isinited(void)
 321 {
 322         return cfag12864b_inited;
 323 }
 324 EXPORT_SYMBOL_GPL(cfag12864b_isinited);
 325
 326 /*
 327  * Module Init & Exit
 328  */
 329
 330 static 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
 370 cachealloced:
 371         kfree(cfag12864b_cache);
 372
 373 bufferalloced:
 374         free_page((unsigned long) cfag12864b_buffer);
 375
 376 none:
 377         return ret;
 378 }
 379
 380 static 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
 389 module_init(cfag12864b_init);
 390 module_exit(cfag12864b_exit);
 391
 392 MODULE_LICENSE("GPL v2");
 393 MODULE_AUTHOR("Miguel Ojeda Sandonis <miguel.ojeda.sandonis@gmail.com>");
 394 MODULE_DESCRIPTION("cfag12864b LCD driver");