drivers/char/lcd.c

   1 /*
   2  * LCD, LED and Button interface for Cobalt
   3  *
   4  * This file is subject to the terms and conditions of the GNU General Public
   5  * License.  See the file "COPYING" in the main directory of this archive
   6  * for more details.
   7  *
   8  * Copyright (C) 1996, 1997 by Andrew Bose
   9  *
  10  * Linux kernel version history:
  11  *       March 2001: Ported from 2.0.34  by Liam Davies
  12  *
  13  */
  14 #include <linux/types.h>
  15 #include <linux/errno.h>
  16 #include <linux/miscdevice.h>
  17 #include <linux/slab.h>
  18 #include <linux/ioport.h>
  19 #include <linux/fcntl.h>
  20 #include <linux/mc146818rtc.h>
  21 #include <linux/netdevice.h>
  22 #include <linux/sched.h>
  23 #include <linux/smp_lock.h>
  24 #include <linux/delay.h>
  25
  26 #include <asm/io.h>
  27 #include <asm/uaccess.h>
  28 #include <asm/system.h>
  29
  30 #include "lcd.h"
  31
  32 static int lcd_ioctl(struct inode *inode, struct file *file,
  33                      unsigned int cmd, unsigned long arg);
  34
  35 static unsigned int lcd_present = 1;
  36
  37 /* used in arch/mips/cobalt/reset.c */
  38 int led_state = 0;
  39
  40 #if defined(CONFIG_TULIP) && 0
  41
  42 #define MAX_INTERFACES  8
  43 static linkcheck_func_t linkcheck_callbacks[MAX_INTERFACES];
  44 static void *linkcheck_cookies[MAX_INTERFACES];
  45
  46 int lcd_register_linkcheck_func(int iface_num, void *func, void *cookie)
  47 {
  48         if (iface_num < 0 ||
  49             iface_num >= MAX_INTERFACES ||
  50             linkcheck_callbacks[iface_num] != NULL)
  51                 return -1;
  52         linkcheck_callbacks[iface_num] = (linkcheck_func_t) func;
  53         linkcheck_cookies[iface_num] = cookie;
  54         return 0;
  55 }
  56 #endif
  57
  58 static int lcd_ioctl(struct inode *inode, struct file *file,
  59                      unsigned int cmd, unsigned long arg)
  60 {
  61         struct lcd_display button_display;
  62         unsigned long address, a;
  63
  64         switch (cmd) {
  65         case LCD_On:
  66                 udelay(150);
  67                 BusyCheck();
  68                 LCDWriteInst(0x0F);
  69                 break;
  70
  71         case LCD_Off:
  72                 udelay(150);
  73                 BusyCheck();
  74                 LCDWriteInst(0x08);
  75                 break;
  76
  77         case LCD_Reset:
  78                 udelay(150);
  79                 LCDWriteInst(0x3F);
  80                 udelay(150);
  81                 LCDWriteInst(0x3F);
  82                 udelay(150);
  83                 LCDWriteInst(0x3F);
  84                 udelay(150);
  85                 LCDWriteInst(0x3F);
  86                 udelay(150);
  87                 LCDWriteInst(0x01);
  88                 udelay(150);
  89                 LCDWriteInst(0x06);
  90                 break;
  91
  92         case LCD_Clear:
  93                 udelay(150);
  94                 BusyCheck();
  95                 LCDWriteInst(0x01);
  96                 break;
  97
  98         case LCD_Cursor_Left:
  99                 udelay(150);
 100                 BusyCheck();
 101                 LCDWriteInst(0x10);
 102                 break;
 103
 104         case LCD_Cursor_Right:
 105                 udelay(150);
 106                 BusyCheck();
 107                 LCDWriteInst(0x14);
 108                 break;
 109
 110         case LCD_Cursor_Off:
 111                 udelay(150);
 112                 BusyCheck();
 113                 LCDWriteInst(0x0C);
 114                 break;
 115
 116         case LCD_Cursor_On:
 117                 udelay(150);
 118                 BusyCheck();
 119                 LCDWriteInst(0x0F);
 120                 break;
 121
 122         case LCD_Blink_Off:
 123                 udelay(150);
 124                 BusyCheck();
 125                 LCDWriteInst(0x0E);
 126                 break;
 127
 128         case LCD_Get_Cursor_Pos:{
 129                         struct lcd_display display;
 130
 131                         udelay(150);
 132                         BusyCheck();
 133                         display.cursor_address = (LCDReadInst);
 134                         display.cursor_address =
 135                             (display.cursor_address & 0x07F);
 136                         if (copy_to_user
 137                             ((struct lcd_display *) arg, &display,
 138                              sizeof(struct lcd_display)))
 139                                 return -EFAULT;
 140
 141                         break;
 142                 }
 143
 144
 145         case LCD_Set_Cursor_Pos:{
 146                         struct lcd_display display;
 147
 148                         if (copy_from_user
 149                             (&display, (struct lcd_display *) arg,
 150                              sizeof(struct lcd_display)))
 151                                 return -EFAULT;
 152
 153                         a = (display.cursor_address | kLCD_Addr);
 154
 155                         udelay(150);
 156                         BusyCheck();
 157                         LCDWriteInst(a);
 158
 159                         break;
 160                 }
 161
 162         case LCD_Get_Cursor:{
 163                         struct lcd_display display;
 164
 165                         udelay(150);
 166                         BusyCheck();
 167                         display.character = LCDReadData;
 168
 169                         if (copy_to_user
 170                             ((struct lcd_display *) arg, &display,
 171                              sizeof(struct lcd_display)))
 172                                 return -EFAULT;
 173                         udelay(150);
 174                         BusyCheck();
 175                         LCDWriteInst(0x10);
 176
 177                         break;
 178                 }
 179
 180         case LCD_Set_Cursor:{
 181                         struct lcd_display display;
 182
 183                         if (copy_from_user
 184                             (&display, (struct lcd_display *) arg,
 185                              sizeof(struct lcd_display)))
 186                                 return -EFAULT;
 187
 188                         udelay(150);
 189                         BusyCheck();
 190                         LCDWriteData(display.character);
 191                         udelay(150);
 192                         BusyCheck();
 193                         LCDWriteInst(0x10);
 194
 195                         break;
 196                 }
 197
 198
 199         case LCD_Disp_Left:
 200                 udelay(150);
 201                 BusyCheck();
 202                 LCDWriteInst(0x18);
 203                 break;
 204
 205         case LCD_Disp_Right:
 206                 udelay(150);
 207                 BusyCheck();
 208                 LCDWriteInst(0x1C);
 209                 break;
 210
 211         case LCD_Home:
 212                 udelay(150);
 213                 BusyCheck();
 214                 LCDWriteInst(0x02);
 215                 break;
 216
 217         case LCD_Write:{
 218                         struct lcd_display display;
 219                         unsigned int index;
 220
 221
 222                         if (copy_from_user
 223                             (&display, (struct lcd_display *) arg,
 224                              sizeof(struct lcd_display)))
 225                                 return -EFAULT;
 226
 227                         udelay(150);
 228                         BusyCheck();
 229                         LCDWriteInst(0x80);
 230                         udelay(150);
 231                         BusyCheck();
 232
 233                         for (index = 0; index < (display.size1); index++) {
 234                                 udelay(150);
 235                                 BusyCheck();
 236                                 LCDWriteData(display.line1[index]);
 237                                 BusyCheck();
 238                         }
 239
 240                         udelay(150);
 241                         BusyCheck();
 242                         LCDWriteInst(0xC0);
 243                         udelay(150);
 244                         BusyCheck();
 245                         for (index = 0; index < (display.size2); index++) {
 246                                 udelay(150);
 247                                 BusyCheck();
 248                                 LCDWriteData(display.line2[index]);
 249                         }
 250
 251                         break;
 252                 }
 253
 254         case LCD_Read:{
 255                         struct lcd_display display;
 256
 257                         BusyCheck();
 258                         for (address = kDD_R00; address <= kDD_R01;
 259                              address++) {
 260                                 a = (address | kLCD_Addr);
 261
 262                                 udelay(150);
 263                                 BusyCheck();
 264                                 LCDWriteInst(a);
 265                                 udelay(150);
 266                                 BusyCheck();
 267                                 display.line1[address] = LCDReadData;
 268                         }
 269
 270                         display.line1[0x27] = '\0';
 271
 272                         for (address = kDD_R10; address <= kDD_R11;
 273                              address++) {
 274                                 a = (address | kLCD_Addr);
 275
 276                                 udelay(150);
 277                                 BusyCheck();
 278                                 LCDWriteInst(a);
 279
 280                                 udelay(150);
 281                                 BusyCheck();
 282                                 display.line2[address - 0x40] =
 283                                     LCDReadData;
 284                         }
 285
 286                         display.line2[0x27] = '\0';
 287
 288                         if (copy_to_user
 289                             ((struct lcd_display *) arg, &display,
 290                              sizeof(struct lcd_display)))
 291                                 return -EFAULT;
 292                         break;
 293                 }
 294
 295 //  set all GPIO leds to led_display.leds
 296
 297         case LED_Set:{
 298                         struct lcd_display led_display;
 299
 300
 301                         if (copy_from_user
 302                             (&led_display, (struct lcd_display *) arg,
 303                              sizeof(struct lcd_display)))
 304                                 return -EFAULT;
 305
 306                         led_state = led_display.leds;
 307                         LEDSet(led_state);
 308
 309                         break;
 310                 }
 311
 312
 313 //  set only bit led_display.leds
 314
 315         case LED_Bit_Set:{
 316                         unsigned int i;
 317                         int bit = 1;
 318                         struct lcd_display led_display;
 319
 320
 321                         if (copy_from_user
 322                             (&led_display, (struct lcd_display *) arg,
 323                              sizeof(struct lcd_display)))
 324                                 return -EFAULT;
 325
 326                         for (i = 0; i < (int) led_display.leds; i++) {
 327                                 bit = 2 * bit;
 328                         }
 329
 330                         led_state = led_state | bit;
 331                         LEDSet(led_state);
 332                         break;
 333                 }
 334
 335 //  clear only bit led_display.leds
 336
 337         case LED_Bit_Clear:{
 338                         unsigned int i;
 339                         int bit = 1;
 340                         struct lcd_display led_display;
 341
 342
 343                         if (copy_from_user
 344                             (&led_display, (struct lcd_display *) arg,
 345                              sizeof(struct lcd_display)))
 346                                 return -EFAULT;
 347
 348                         for (i = 0; i < (int) led_display.leds; i++) {
 349                                 bit = 2 * bit;
 350                         }
 351
 352                         led_state = led_state & ~bit;
 353                         LEDSet(led_state);
 354                         break;
 355                 }
 356
 357
 358         case BUTTON_Read:{
 359                         button_display.buttons = GPIRead;
 360                         if (copy_to_user
 361                             ((struct lcd_display *) arg, &button_display,
 362                              sizeof(struct lcd_display)))
 363                                 return -EFAULT;
 364                         break;
 365                 }
 366
 367         case LINK_Check:{
 368                         button_display.buttons =
 369                             *((volatile unsigned long *) (0xB0100060));
 370                         if (copy_to_user
 371                             ((struct lcd_display *) arg, &button_display,
 372                              sizeof(struct lcd_display)))
 373                                 return -EFAULT;
 374                         break;
 375                 }
 376
 377         case LINK_Check_2:{
 378                         int iface_num;
 379
 380                         /* panel-utils should pass in the desired interface status is wanted for
 381                          * in "buttons" of the structure.  We will set this to non-zero if the
 382                          * link is in fact up for the requested interface.  --DaveM
 383                          */
 384                         if (copy_from_user
 385                             (&button_display, (struct lcd_display *) arg,
 386                              sizeof(button_display)))
 387                                 return -EFAULT;
 388                         iface_num = button_display.buttons;
 389 #if defined(CONFIG_TULIP) && 0
 390                         if (iface_num >= 0 &&
 391                             iface_num < MAX_INTERFACES &&
 392                             linkcheck_callbacks[iface_num] != NULL) {
 393                                 button_display.buttons =
 394                                     linkcheck_callbacks[iface_num]
 395                                     (linkcheck_cookies[iface_num]);
 396                         } else
 397 #endif
 398                                 button_display.buttons = 0;
 399
 400                         if (__copy_to_user
 401                             ((struct lcd_display *) arg, &button_display,
 402                              sizeof(struct lcd_display)))
 403                                 return -EFAULT;
 404                         break;
 405                 }
 406
 407         default:
 408                 return -EINVAL;
 409
 410         }
 411
 412         return 0;
 413
 414 }
 415
 416 static int lcd_open(struct inode *inode, struct file *file)
 417 {
 418         cycle_kernel_lock();
 419
 420         if (!lcd_present)
 421                 return -ENXIO;
 422         else
 423                 return 0;
 424 }
 425
 426 /* Only RESET or NEXT counts as button pressed */
 427
 428 static inline int button_pressed(void)
 429 {
 430         unsigned long buttons = GPIRead;
 431
 432         if ((buttons == BUTTON_Next) || (buttons == BUTTON_Next_B)
 433             || (buttons == BUTTON_Reset_B))
 434                 return buttons;
 435         return 0;
 436 }
 437
 438 /* LED daemon sits on this and we wake him up once a key is pressed. */
 439
 440 static int lcd_waiters = 0;
 441
 442 static ssize_t lcd_read(struct file *file, char *buf,
 443                      size_t count, loff_t *ofs)
 444 {
 445         long buttons_now;
 446
 447         if (lcd_waiters > 0)
 448                 return -EINVAL;
 449
 450         lcd_waiters++;
 451         while (((buttons_now = (long) button_pressed()) == 0) &&
 452                !(signal_pending(current))) {
 453                 msleep_interruptible(2000);
 454         }
 455         lcd_waiters--;
 456
 457         if (signal_pending(current))
 458                 return -ERESTARTSYS;
 459         return buttons_now;
 460 }
 461
 462 /*
 463  *      The various file operations we support.
 464  */
 465
 466 static const struct file_operations lcd_fops = {
 467         .read = lcd_read,
 468         .ioctl = lcd_ioctl,
 469         .open = lcd_open,
 470 };
 471
 472 static struct miscdevice lcd_dev = {
 473         MISC_DYNAMIC_MINOR,
 474         "lcd",
 475         &lcd_fops
 476 };
 477
 478 static int lcd_init(void)
 479 {
 480         int ret;
 481         unsigned long data;
 482
 483         pr_info("%s\n", LCD_DRIVER);
 484         ret = misc_register(&lcd_dev);
 485         if (ret) {
 486                 printk(KERN_WARNING LCD "Unable to register misc device.\n");
 487                 return ret;
 488         }
 489
 490         /* Check region? Naaah! Just snarf it up. */
 491 /*      request_region(RTC_PORT(0), RTC_IO_EXTENT, "lcd");*/
 492
 493         udelay(150);
 494         data = LCDReadData;
 495         if ((data & 0x000000FF) == (0x00)) {
 496                 lcd_present = 0;
 497                 pr_info(LCD "LCD Not Present\n");
 498         } else {
 499                 lcd_present = 1;
 500                 WRITE_GAL(kGal_DevBank2PReg, kGal_DevBank2Cfg);
 501                 WRITE_GAL(kGal_DevBank3PReg, kGal_DevBank3Cfg);
 502         }
 503
 504         return 0;
 505 }
 506
 507 static void __exit lcd_exit(void)
 508 {
 509         misc_deregister(&lcd_dev);
 510 }
 511
 512 module_init(lcd_init);
 513 module_exit(lcd_exit);
 514
 515 MODULE_AUTHOR("Andrew Bose");
 516 MODULE_LICENSE("GPL");