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/delay.h>
  24
  25 #include <asm/io.h>
  26 #include <asm/uaccess.h>
  27 #include <asm/system.h>
  28 #include <linux/delay.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         if (!lcd_present)
 419                 return -ENXIO;
 420         else
 421                 return 0;
 422 }
 423
 424 /* Only RESET or NEXT counts as button pressed */
 425
 426 static inline int button_pressed(void)
 427 {
 428         unsigned long buttons = GPIRead;
 429
 430         if ((buttons == BUTTON_Next) || (buttons == BUTTON_Next_B)
 431             || (buttons == BUTTON_Reset_B))
 432                 return buttons;
 433         return 0;
 434 }
 435
 436 /* LED daemon sits on this and we wake him up once a key is pressed. */
 437
 438 static int lcd_waiters = 0;
 439
 440 static ssize_t lcd_read(struct file *file, char *buf,
 441                      size_t count, loff_t *ofs)
 442 {
 443         long buttons_now;
 444
 445         if (lcd_waiters > 0)
 446                 return -EINVAL;
 447
 448         lcd_waiters++;
 449         while (((buttons_now = (long) button_pressed()) == 0) &&
 450                !(signal_pending(current))) {
 451                 msleep_interruptible(2000);
 452         }
 453         lcd_waiters--;
 454
 455         if (signal_pending(current))
 456                 return -ERESTARTSYS;
 457         return buttons_now;
 458 }
 459
 460 /*
 461  *      The various file operations we support.
 462  */
 463
 464 static const struct file_operations lcd_fops = {
 465         .read = lcd_read,
 466         .ioctl = lcd_ioctl,
 467         .open = lcd_open,
 468 };
 469
 470 static struct miscdevice lcd_dev = {
 471         MISC_DYNAMIC_MINOR,
 472         "lcd",
 473         &lcd_fops
 474 };
 475
 476 static int lcd_init(void)
 477 {
 478         int ret;
 479         unsigned long data;
 480
 481         pr_info("%s\n", LCD_DRIVER);
 482         ret = misc_register(&lcd_dev);
 483         if (ret) {
 484                 printk(KERN_WARNING LCD "Unable to register misc device.\n");
 485                 return ret;
 486         }
 487
 488         /* Check region? Naaah! Just snarf it up. */
 489 /*      request_region(RTC_PORT(0), RTC_IO_EXTENT, "lcd");*/
 490
 491         udelay(150);
 492         data = LCDReadData;
 493         if ((data & 0x000000FF) == (0x00)) {
 494                 lcd_present = 0;
 495                 pr_info(LCD "LCD Not Present\n");
 496         } else {
 497                 lcd_present = 1;
 498                 WRITE_GAL(kGal_DevBank2PReg, kGal_DevBank2Cfg);
 499                 WRITE_GAL(kGal_DevBank3PReg, kGal_DevBank3Cfg);
 500         }
 501
 502         return 0;
 503 }
 504
 505 static void __exit lcd_exit(void)
 506 {
 507         misc_deregister(&lcd_dev);
 508 }
 509
 510 module_init(lcd_init);
 511 module_exit(lcd_exit);
 512
 513 MODULE_AUTHOR("Andrew Bose");
 514 MODULE_LICENSE("GPL");