Logo Search packages:      
Sourcecode: linux version File versions  Download package

lcd.c

/*
 * LCD, LED and Button interface for Cobalt
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 1996, 1997 by Andrew Bose
 *
 * Linux kernel version history:
 *       March 2001: Ported from 2.0.34  by Liam Davies
 *
 */
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <linux/fcntl.h>
#include <linux/mc146818rtc.h>
#include <linux/netdevice.h>
#include <linux/sched.h>
#include <linux/delay.h>

#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/system.h>

#include "lcd.h"

static int lcd_ioctl(struct inode *inode, struct file *file,
                 unsigned int cmd, unsigned long arg);

static unsigned int lcd_present = 1;

/* used in arch/mips/cobalt/reset.c */
int led_state = 0;

#if defined(CONFIG_TULIP) && 0

#define MAX_INTERFACES  8
static linkcheck_func_t linkcheck_callbacks[MAX_INTERFACES];
static void *linkcheck_cookies[MAX_INTERFACES];

int lcd_register_linkcheck_func(int iface_num, void *func, void *cookie)
{
      if (iface_num < 0 ||
          iface_num >= MAX_INTERFACES ||
          linkcheck_callbacks[iface_num] != NULL)
            return -1;
      linkcheck_callbacks[iface_num] = (linkcheck_func_t) func;
      linkcheck_cookies[iface_num] = cookie;
      return 0;
}
#endif

static int lcd_ioctl(struct inode *inode, struct file *file,
                 unsigned int cmd, unsigned long arg)
{
      struct lcd_display button_display;
      unsigned long address, a;

      switch (cmd) {
      case LCD_On:
            udelay(150);
            BusyCheck();
            LCDWriteInst(0x0F);
            break;

      case LCD_Off:
            udelay(150);
            BusyCheck();
            LCDWriteInst(0x08);
            break;

      case LCD_Reset:
            udelay(150);
            LCDWriteInst(0x3F);
            udelay(150);
            LCDWriteInst(0x3F);
            udelay(150);
            LCDWriteInst(0x3F);
            udelay(150);
            LCDWriteInst(0x3F);
            udelay(150);
            LCDWriteInst(0x01);
            udelay(150);
            LCDWriteInst(0x06);
            break;

      case LCD_Clear:
            udelay(150);
            BusyCheck();
            LCDWriteInst(0x01);
            break;

      case LCD_Cursor_Left:
            udelay(150);
            BusyCheck();
            LCDWriteInst(0x10);
            break;

      case LCD_Cursor_Right:
            udelay(150);
            BusyCheck();
            LCDWriteInst(0x14);
            break;

      case LCD_Cursor_Off:
            udelay(150);
            BusyCheck();
            LCDWriteInst(0x0C);
            break;

      case LCD_Cursor_On:
            udelay(150);
            BusyCheck();
            LCDWriteInst(0x0F);
            break;

      case LCD_Blink_Off:
            udelay(150);
            BusyCheck();
            LCDWriteInst(0x0E);
            break;

      case LCD_Get_Cursor_Pos:{
                  struct lcd_display display;

                  udelay(150);
                  BusyCheck();
                  display.cursor_address = (LCDReadInst);
                  display.cursor_address =
                      (display.cursor_address & 0x07F);
                  if (copy_to_user
                      ((struct lcd_display *) arg, &display,
                       sizeof(struct lcd_display)))
                        return -EFAULT;

                  break;
            }


      case LCD_Set_Cursor_Pos:{
                  struct lcd_display display;

                  if (copy_from_user
                      (&display, (struct lcd_display *) arg,
                       sizeof(struct lcd_display)))
                        return -EFAULT;

                  a = (display.cursor_address | kLCD_Addr);

                  udelay(150);
                  BusyCheck();
                  LCDWriteInst(a);

                  break;
            }

      case LCD_Get_Cursor:{
                  struct lcd_display display;

                  udelay(150);
                  BusyCheck();
                  display.character = LCDReadData;

                  if (copy_to_user
                      ((struct lcd_display *) arg, &display,
                       sizeof(struct lcd_display)))
                        return -EFAULT;
                  udelay(150);
                  BusyCheck();
                  LCDWriteInst(0x10);

                  break;
            }

      case LCD_Set_Cursor:{
                  struct lcd_display display;

                  if (copy_from_user
                      (&display, (struct lcd_display *) arg,
                       sizeof(struct lcd_display)))
                        return -EFAULT;

                  udelay(150);
                  BusyCheck();
                  LCDWriteData(display.character);
                  udelay(150);
                  BusyCheck();
                  LCDWriteInst(0x10);

                  break;
            }


      case LCD_Disp_Left:
            udelay(150);
            BusyCheck();
            LCDWriteInst(0x18);
            break;

      case LCD_Disp_Right:
            udelay(150);
            BusyCheck();
            LCDWriteInst(0x1C);
            break;

      case LCD_Home:
            udelay(150);
            BusyCheck();
            LCDWriteInst(0x02);
            break;

      case LCD_Write:{
                  struct lcd_display display;
                  unsigned int index;


                  if (copy_from_user
                      (&display, (struct lcd_display *) arg,
                       sizeof(struct lcd_display)))
                        return -EFAULT;

                  udelay(150);
                  BusyCheck();
                  LCDWriteInst(0x80);
                  udelay(150);
                  BusyCheck();

                  for (index = 0; index < (display.size1); index++) {
                        udelay(150);
                        BusyCheck();
                        LCDWriteData(display.line1[index]);
                        BusyCheck();
                  }

                  udelay(150);
                  BusyCheck();
                  LCDWriteInst(0xC0);
                  udelay(150);
                  BusyCheck();
                  for (index = 0; index < (display.size2); index++) {
                        udelay(150);
                        BusyCheck();
                        LCDWriteData(display.line2[index]);
                  }

                  break;
            }

      case LCD_Read:{
                  struct lcd_display display;

                  BusyCheck();
                  for (address = kDD_R00; address <= kDD_R01;
                       address++) {
                        a = (address | kLCD_Addr);

                        udelay(150);
                        BusyCheck();
                        LCDWriteInst(a);
                        udelay(150);
                        BusyCheck();
                        display.line1[address] = LCDReadData;
                  }

                  display.line1[0x27] = '\0';

                  for (address = kDD_R10; address <= kDD_R11;
                       address++) {
                        a = (address | kLCD_Addr);

                        udelay(150);
                        BusyCheck();
                        LCDWriteInst(a);

                        udelay(150);
                        BusyCheck();
                        display.line2[address - 0x40] =
                            LCDReadData;
                  }

                  display.line2[0x27] = '\0';

                  if (copy_to_user
                      ((struct lcd_display *) arg, &display,
                       sizeof(struct lcd_display)))
                        return -EFAULT;
                  break;
            }

//  set all GPIO leds to led_display.leds

      case LED_Set:{
                  struct lcd_display led_display;


                  if (copy_from_user
                      (&led_display, (struct lcd_display *) arg,
                       sizeof(struct lcd_display)))
                        return -EFAULT;

                  led_state = led_display.leds;
                  LEDSet(led_state);

                  break;
            }


//  set only bit led_display.leds

      case LED_Bit_Set:{
                  unsigned int i;
                  int bit = 1;
                  struct lcd_display led_display;


                  if (copy_from_user
                      (&led_display, (struct lcd_display *) arg,
                       sizeof(struct lcd_display)))
                        return -EFAULT;

                  for (i = 0; i < (int) led_display.leds; i++) {
                        bit = 2 * bit;
                  }

                  led_state = led_state | bit;
                  LEDSet(led_state);
                  break;
            }

//  clear only bit led_display.leds

      case LED_Bit_Clear:{
                  unsigned int i;
                  int bit = 1;
                  struct lcd_display led_display;


                  if (copy_from_user
                      (&led_display, (struct lcd_display *) arg,
                       sizeof(struct lcd_display)))
                        return -EFAULT;

                  for (i = 0; i < (int) led_display.leds; i++) {
                        bit = 2 * bit;
                  }

                  led_state = led_state & ~bit;
                  LEDSet(led_state);
                  break;
            }


      case BUTTON_Read:{
                  button_display.buttons = GPIRead;
                  if (copy_to_user
                      ((struct lcd_display *) arg, &button_display,
                       sizeof(struct lcd_display)))
                        return -EFAULT;
                  break;
            }

      case LINK_Check:{
                  button_display.buttons =
                      *((volatile unsigned long *) (0xB0100060));
                  if (copy_to_user
                      ((struct lcd_display *) arg, &button_display,
                       sizeof(struct lcd_display)))
                        return -EFAULT;
                  break;
            }

      case LINK_Check_2:{
                  int iface_num;

                  /* panel-utils should pass in the desired interface status is wanted for
                   * in "buttons" of the structure.  We will set this to non-zero if the
                   * link is in fact up for the requested interface.  --DaveM
                   */
                  if (copy_from_user
                      (&button_display, (struct lcd_display *) arg,
                       sizeof(button_display)))
                        return -EFAULT;
                  iface_num = button_display.buttons;
#if defined(CONFIG_TULIP) && 0
                  if (iface_num >= 0 &&
                      iface_num < MAX_INTERFACES &&
                      linkcheck_callbacks[iface_num] != NULL) {
                        button_display.buttons =
                            linkcheck_callbacks[iface_num]
                            (linkcheck_cookies[iface_num]);
                  } else
#endif
                        button_display.buttons = 0;

                  if (__copy_to_user
                      ((struct lcd_display *) arg, &button_display,
                       sizeof(struct lcd_display)))
                        return -EFAULT;
                  break;
            }

      default:
            return -EINVAL;

      }

      return 0;

}

static int lcd_open(struct inode *inode, struct file *file)
{
      if (!lcd_present)
            return -ENXIO;
      else
            return 0;
}

/* Only RESET or NEXT counts as button pressed */

static inline int button_pressed(void)
{
      unsigned long buttons = GPIRead;

      if ((buttons == BUTTON_Next) || (buttons == BUTTON_Next_B)
          || (buttons == BUTTON_Reset_B))
            return buttons;
      return 0;
}

/* LED daemon sits on this and we wake him up once a key is pressed. */

static int lcd_waiters = 0;

static ssize_t lcd_read(struct file *file, char *buf,
                 size_t count, loff_t *ofs)
{
      long buttons_now;

      if (lcd_waiters > 0)
            return -EINVAL;

      lcd_waiters++;
      while (((buttons_now = (long) button_pressed()) == 0) &&
             !(signal_pending(current))) {
            msleep_interruptible(2000);
      }
      lcd_waiters--;

      if (signal_pending(current))
            return -ERESTARTSYS;
      return buttons_now;
}

/*
 *    The various file operations we support.
 */

static const struct file_operations lcd_fops = {
      .read = lcd_read,
      .ioctl = lcd_ioctl,
      .open = lcd_open,
};

static struct miscdevice lcd_dev = {
      MISC_DYNAMIC_MINOR,
      "lcd",
      &lcd_fops
};

static int lcd_init(void)
{
      int ret;
      unsigned long data;

      pr_info("%s\n", LCD_DRIVER);
      ret = misc_register(&lcd_dev);
      if (ret) {
            printk(KERN_WARNING LCD "Unable to register misc device.\n");
            return ret;
      }

      /* Check region? Naaah! Just snarf it up. */
/*    request_region(RTC_PORT(0), RTC_IO_EXTENT, "lcd");*/

      udelay(150);
      data = LCDReadData;
      if ((data & 0x000000FF) == (0x00)) {
            lcd_present = 0;
            pr_info(LCD "LCD Not Present\n");
      } else {
            lcd_present = 1;
            WRITE_GAL(kGal_DevBank2PReg, kGal_DevBank2Cfg);
            WRITE_GAL(kGal_DevBank3PReg, kGal_DevBank3Cfg);
      }

      return 0;
}

static void __exit lcd_exit(void)
{
      misc_deregister(&lcd_dev);
}

module_init(lcd_init);
module_exit(lcd_exit);

MODULE_AUTHOR("Andrew Bose");
MODULE_LICENSE("GPL");

Generated by  Doxygen 1.6.0   Back to index