开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
lcd.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：13k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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.  */
  15. #define RTC_IO_EXTENT 0x10    /*Only really two ports, but... */
  17. #include <linux/types.h>
  18. #include <linux/errno.h>
  19. #include <linux/miscdevice.h>
  20. #include <linux/slab.h>
  21. #include <linux/ioport.h>
  22. #include <linux/fcntl.h>
  23. #include <linux/mc146818rtc.h>
  24. #include <linux/netdevice.h>
  25. #include <linux/sched.h>
  27. #include <asm/io.h>
  28. #include <asm/uaccess.h>
  29. #include <asm/system.h>
  30. #include <linux/delay.h>
  32. #include "lcd.h"
  34. static int lcd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, 
  35.                      unsigned long arg);
  37. static int lcd_present = 1;
  39. int led_state = 0;
  41. #if defined(CONFIG_TULIP) && 0
  43. #define MAX_INTERFACES 8
  44. static linkcheck_func_t linkcheck_callbacks[MAX_INTERFACES];
  45. static void *linkcheck_cookies[MAX_INTERFACES];
  47. int lcd_register_linkcheck_func(int iface_num, void *func, void *cookie)
  48. {
  49. if (iface_num < 0 ||
  50.     iface_num >= MAX_INTERFACES ||
  51.     linkcheck_callbacks[iface_num] != NULL)
  52. return -1;
  53. linkcheck_callbacks[iface_num] = (linkcheck_func_t) func;
  54. linkcheck_cookies[iface_num] = cookie;
  55. return 0;
  56. }
  57. #endif
  59. static int lcd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, 
  60. unsigned long arg)
  61. {
  62. struct lcd_display button_display;
  63. unsigned long address, a;
  64. int index;
  66. switch (cmd) {
  67. case LCD_On:
  68. udelay(150);
  69. BusyCheck();
  70. LCDWriteInst(0x0F);
  71. break;
  73. case LCD_Off:
  74. udelay(150);
  75. BusyCheck();
  76. LCDWriteInst(0x08);
  77. break;
  79. case LCD_Reset:
  80. udelay(150);
  81. LCDWriteInst(0x3F);
  82. udelay(150);
  83. LCDWriteInst(0x3F);
  84. udelay(150);
  85. LCDWriteInst(0x3F);
  86. udelay(150);
  87. LCDWriteInst(0x3F);
  88. udelay(150);
  89. LCDWriteInst(0x01);
  90. udelay(150);
  91. LCDWriteInst(0x06);
  92. break;
  94. case LCD_Clear:
  95. udelay(150);
  96. BusyCheck();
  97.         LCDWriteInst(0x01);     
  98. break;
  100. case LCD_Cursor_Left:
  101. udelay(150);
  102. BusyCheck();
  103. LCDWriteInst(0x10);
  104. break;
  106. case LCD_Cursor_Right:
  107. udelay(150);
  108. BusyCheck();
  109. LCDWriteInst(0x14);
  110. break;
  112. case LCD_Cursor_Off:
  113. udelay(150);
  114.                 BusyCheck();
  115.                 LCDWriteInst(0x0C);
  116.         break;
  118.         case LCD_Cursor_On:
  119.                 udelay(150);
  120.                 BusyCheck();
  121.                 LCDWriteInst(0x0F);
  122.                 break;
  124.         case LCD_Blink_Off:
  125.                 udelay(150);
  126.                 BusyCheck();
  127.                 LCDWriteInst(0x0E);
  128.                 break;
  130. case LCD_Get_Cursor_Pos:{
  131.                 struct lcd_display display;
  133. udelay(150);
  134.                 BusyCheck();
  135. display.cursor_address = ( LCDReadInst ); 
  136. display.cursor_address = ( display.cursor_address & 0x07F );
  137. if(copy_to_user((struct lcd_display*)arg, &display, sizeof(struct lcd_display)))
  138.   return -EFAULT;
  140. break;
  141. }
  144. case LCD_Set_Cursor_Pos: {
  145.                 struct lcd_display display;
  147.                 if(copy_from_user(&display, (struct lcd_display*)arg, sizeof(struct lcd_display)))
  148.   return -EFAULT;
  150. a = (display.cursor_address | kLCD_Addr ); 
  152.                 udelay(150);
  153.                 BusyCheck();    
  154.                 LCDWriteInst( a );
  156.                 break;
  157. }
  159. case LCD_Get_Cursor: {
  160.                 struct lcd_display display;
  162.                 udelay(150);
  163.                 BusyCheck();    
  164. display.character = LCDReadData;
  166. if(copy_to_user((struct lcd_display*)arg, &display, sizeof(struct lcd_display)))
  167.   return -EFAULT;
  168.                 udelay(150);
  169.                 BusyCheck();
  170.                 LCDWriteInst(0x10);
  172. break;
  173. }
  175. case LCD_Set_Cursor:{
  176.                 struct lcd_display display;
  177.    
  178.                 if(copy_from_user(&display, (struct lcd_display*)arg, sizeof(struct lcd_display)))
  179.   return -EFAULT;
  181.                 udelay(150);
  182. BusyCheck();    
  183.                 LCDWriteData( display.character );
  184.                 udelay(150);
  185.                 BusyCheck();
  186.                 LCDWriteInst(0x10);
  188.                 break;
  189.                 }
  192. case LCD_Disp_Left:
  193. udelay(150);
  194. BusyCheck();
  195. LCDWriteInst(0x18);
  196. break;
  198. case LCD_Disp_Right:
  199. udelay(150);
  200. BusyCheck();
  201. LCDWriteInst(0x1C);
  202. break;
  204. case LCD_Home:
  205. udelay(150);
  206. BusyCheck();
  207. LCDWriteInst(0x02);
  208. break;
  210. case LCD_Write: {
  211. struct lcd_display display;
  212.    
  214.                 if(copy_from_user(&display, (struct lcd_display*)arg, sizeof(struct lcd_display)))
  215.   return -EFAULT;
  216.  
  217. udelay(150);
  218.                 BusyCheck();    
  219.                 LCDWriteInst(0x80);
  220. udelay(150);
  221. BusyCheck();
  223. for (index = 0; index < (display.size1); index++) {
  224. udelay(150);
  225. BusyCheck();
  226. LCDWriteData( display.line1[index]);
  227. BusyCheck();
  228. }
  230. udelay(150);
  231. BusyCheck();
  232. LCDWriteInst(0xC0);
  233. udelay(150);
  234. BusyCheck();
  235.                 for (index = 0; index < (display.size2); index++) {
  236.                         udelay(150);
  237.                         BusyCheck();    
  238.                         LCDWriteData( display.line2[index]);
  239. }
  240.  
  241. break;
  242. }
  244. case LCD_Read: {
  245.          struct lcd_display display;
  247. BusyCheck();
  248. for (address = kDD_R00; address <= kDD_R01; address++) {
  249. a = (address | kLCD_Addr );
  251. udelay(150);
  252. BusyCheck();
  253. LCDWriteInst( a );
  254. udelay(150);
  255. BusyCheck();
  256. display.line1[address] = LCDReadData;
  257. }
  259. display.line1[ 0x27 ] = '';
  261. for (address = kDD_R10; address <= kDD_R11; address++) {
  262. a = (address | kLCD_Addr );     
  263.         
  264. udelay(150);
  265.   BusyCheck();
  266.          LCDWriteInst( a );
  267.        
  268.          udelay(150);
  269.   BusyCheck();
  270.          display.line2[address - 0x40 ] = LCDReadData;
  271.  }
  273. display.line2[ 0x27 ] = '';
  275. if(copy_to_user((struct lcd_display*)arg, &display,
  276. sizeof(struct lcd_display)))
  277.   return -EFAULT;
  278. break;
  279. }
  281. //  set all GPIO leds to led_display.leds 
  283. case LED_Set: {
  284. struct lcd_display led_display;
  287.         if(copy_from_user(&led_display, (struct lcd_display*)arg,
  288.   sizeof(struct lcd_display)))
  289.   return -EFAULT;
  291. led_state = led_display.leds;
  292. LEDSet(led_state);
  294.          break;
  295. }
  298. //  set only bit led_display.leds
  300.         case LED_Bit_Set: {
  301.                 int i;
  302. int bit=1;
  303.                 struct lcd_display led_display;
  306.                 if(copy_from_user(&led_display, (struct lcd_display*)arg,
  307.   sizeof(struct lcd_display)))
  308.   return -EFAULT;
  310. for (i=0;i<(int)led_display.leds;i++)
  311. {
  312. bit = 2*bit;
  313. }
  315. led_state = led_state | bit;
  316.                 LEDSet(led_state);
  317.                 break;
  318.         }
  320. //  clear only bit led_display.leds
  322.         case LED_Bit_Clear: {
  323.                 int i;
  324. int bit=1;
  325.                 struct lcd_display led_display;
  328.                 if(copy_from_user(&led_display, (struct lcd_display*)arg,
  329.   sizeof(struct lcd_display)))
  330.   return -EFAULT;
  332.                 for (i=0;i<(int)led_display.leds;i++)
  333.                         {
  334.                                 bit = 2*bit;
  335.                         }
  337. led_state = led_state &  ~bit;
  338.                 LEDSet(led_state);
  339.                 break;
  340.         }
  343. case BUTTON_Read: {
  344. button_display.buttons = GPIRead;
  345.                 if(copy_to_user((struct lcd_display*)arg, &button_display, sizeof(struct lcd_display)))
  346.   return -EFAULT;
  347. break;
  348. }
  350.         case LINK_Check: {
  351.                 button_display.buttons = *((volatile unsigned long *) (0xB0100060) );
  352.                 if(copy_to_user((struct lcd_display*)arg, &button_display, sizeof(struct lcd_display)))
  353.   return -EFAULT;
  354.                 break;
  355.         }
  357. case LINK_Check_2: {
  358. int iface_num;
  360. /* panel-utils should pass in the desired interface status is wanted for
  361.  * in "buttons" of the structure.  We will set this to non-zero if the
  362.  * link is in fact up for the requested interface.  --DaveM
  363.  */
  364. if(copy_from_user(&button_display, (struct lcd_display *)arg, sizeof(button_display)))
  365.   return -EFAULT;
  366. iface_num = button_display.buttons;
  367. #if defined(CONFIG_TULIP) && 0
  368. if (iface_num >= 0 &&
  369.     iface_num < MAX_INTERFACES &&
  370.     linkcheck_callbacks[iface_num] != NULL) {
  371. button_display.buttons =
  372. linkcheck_callbacks[iface_num](linkcheck_cookies[iface_num]);
  373. } else
  374. #endif
  375. button_display.buttons = 0;
  377.                 if(__copy_to_user((struct lcd_display*)arg, &button_display, sizeof(struct lcd_display)))
  378.   return -EFAULT;
  379.                 break;
  380. }
  382. //  Erase the flash
  384. case FLASH_Erase: {
  386. int ctr=0;
  388.     // Chip Erase Sequence
  389. WRITE_FLASH( kFlash_Addr1, kFlash_Data1 );
  390. WRITE_FLASH( kFlash_Addr2, kFlash_Data2 );
  391. WRITE_FLASH( kFlash_Addr1, kFlash_Erase3 );
  392. WRITE_FLASH( kFlash_Addr1, kFlash_Data1 );
  393. WRITE_FLASH( kFlash_Addr2, kFlash_Data2 );
  394. WRITE_FLASH( kFlash_Addr1, kFlash_Erase6 );
  396. printk( "Erasing Flash.n");
  398. while ( (!dqpoll(0x00000000,0xFF)) && (!timeout(0x00000000)) ) {
  399.     ctr++;
  400. }
  402. printk("n");
  403. printk("n");
  404. printk("n");
  406. if (READ_FLASH(0x07FFF0)==0xFF) { printk("Erase Successfulrn"); }
  407. else if (timeout) { printk("Erase Timed Outrn"); }
  409. break;
  410. }
  412. // burn the flash 
  414. case FLASH_Burn: {
  416. volatile unsigned long burn_addr;
  417. unsigned long flags;
  418. int i;
  419. unsigned char *rom;
  422.                 struct lcd_display display;
  424.                 if(copy_from_user(&display, (struct lcd_display*)arg, sizeof(struct lcd_display)))
  425.   return -EFAULT;
  426. rom = (unsigned char *) kmalloc((128),GFP_ATOMIC);
  427.                 if ( rom == NULL ) {
  428.                        printk ("brokenn");
  429.                        return 1;
  430.                    }
  432. printk("Churning and Burning -");
  433. save_flags(flags);
  434. for (i=0; i<FLASH_SIZE; i=i+128) {
  436.         if(copy_from_user(rom, display.RomImage + i, 128))
  437.    return -EFAULT;
  438. burn_addr = kFlashBase + i;
  439. cli();
  440. for ( index = 0; index < ( 128 ) ; index++ ) 
  441.      {
  443. WRITE_FLASH( kFlash_Addr1, kFlash_Data1 );
  444.        WRITE_FLASH( kFlash_Addr2, kFlash_Data2 );
  445.        WRITE_FLASH( kFlash_Addr1, kFlash_Prog );
  446.        *((volatile unsigned char *)burn_addr) = (volatile unsigned char) rom[index];
  448.        while ( (!dqpoll(burn_addr,(volatile unsigned char) rom[index])) && (!timeout(burn_addr)) ) {
  449.        }
  450.        burn_addr++;
  451.      }
  452. restore_flags(flags);
  453.                  if ( *((volatile unsigned char *)(burn_addr-1)) == (volatile unsigned char) rom[index-1]  ) {
  454.                  } else if (timeout) {
  455.                      printk("Program timed outrn");
  456.                  }
  459. }
  460. kfree(rom);
  462. break;
  463. }
  465. //  read the flash all at once 
  467. case FLASH_Read: {
  469. unsigned char *user_bytes;
  470.                 volatile unsigned long read_addr;
  471.                 int i;
  473. user_bytes = &(((struct lcd_display *)arg)->RomImage[0]);
  475. if(!access_ok(VERIFY_WRITE, user_bytes, FLASH_SIZE))
  476.                          return -EFAULT;
  478. printk("Reading Flash");
  479. for (i=0; i<FLASH_SIZE; i++) {
  480. unsigned char tmp_byte;
  481. read_addr = kFlashBase + i;
  482. tmp_byte = *((volatile unsigned char *)read_addr);
  483. if(__put_user (tmp_byte, &user_bytes[i]))
  484.   return -EFAULT;
  485. }
  488. break;
  489. }
  495. default:
  496. return 0;
  497. break;
  499. }
  501. return 0;
  503. }
  505. static int lcd_open(struct inode *inode, struct file *file)
  506. {
  507. if (!lcd_present)
  508. return -ENXIO;
  509. else
  510. return 0;
  511. }
  513. /* Only RESET or NEXT counts as button pressed */
  515. static inline int button_pressed(void)
  516. {
  517. unsigned long buttons = GPIRead;
  519. if ( (buttons == BUTTON_Next) || (buttons == BUTTON_Next_B) || (buttons == BUTTON_Reset_B) )
  520. return buttons;
  521. return 0;
  522. }
  524. /* LED daemon sits on this and we wake him up once a key is pressed. */
  526. static int lcd_waiters = 0;
  528. static long lcd_read(struct inode *inode, struct file *file, char *buf, unsigned long count)
  529. {
  530. long buttons_now;
  532. if(lcd_waiters > 0)
  533. return -EINVAL;
  535. lcd_waiters++;
  536. while(((buttons_now = (long)button_pressed()) == 0) &&
  537.       !(signal_pending(current))) {
  538. current->state = TASK_INTERRUPTIBLE;
  539. schedule_timeout(2 * HZ);
  540. }
  541. lcd_waiters--;
  543. if(signal_pending(current))
  544. return -ERESTARTSYS;
  545. return buttons_now;
  546. }
  548. /*
  549.  * The various file operations we support.
  550.  */
  552. static struct file_operations lcd_fops = {
  553. read: lcd_read,
  554. ioctl: lcd_ioctl,
  555. open: lcd_open,
  556. };
  558. static struct miscdevice lcd_dev=
  559. {
  560. LCD_MINOR,
  561. "lcd",
  562. &lcd_fops
  563. };
  565. int lcd_init(void)
  566. {
  567. unsigned long data;
  569. printk("%sn", LCD_DRIVER);
  570. misc_register(&lcd_dev);
  572. /* Check region? Naaah! Just snarf it up. */
  573. /* request_region(RTC_PORT(0), RTC_IO_EXTENT, "lcd");*/
  575. udelay(150);
  576. data = LCDReadData;
  577. if ( (data & 0x000000FF) == (0x00) ) {
  578. lcd_present = 0;
  579. printk("LCD Not Presentn");
  580.         }
  581. else {
  582. lcd_present = 1;
  583. WRITE_GAL( kGal_DevBank2PReg, kGal_DevBank2Cfg );
  584. WRITE_GAL( kGal_DevBank3PReg, kGal_DevBank3Cfg );
  585. }
  587. return 0;
  588. }
  591. //
  592. // Function: dqpoll
  593. //
  594. // Description:  Polls the data lines to see if the flash is busy
  595. //
  596. // In: address, byte data
  597. //
  598. // Out: 0 = busy, 1 = write or erase complete
  599. //
  600. //
  602. int dqpoll( volatile unsigned long address, volatile unsigned char data ) {
  604. volatile unsigned char dq7;
  606. dq7 = data & 0x80;
  608. return ( (READ_FLASH(address) & 0x80) == dq7  );
  610. }
  613. //
  614. // Function: timeout
  615. //
  616. // Description: Checks to see if erase or write has timed out
  617. //              By polling dq5
  618. //
  619. // In: address
  620. //
  621. //
  622. // Out: 0 = not timed out, 1 = timed out
  624. int timeout( volatile unsigned long address ) {
  627. return (  (READ_FLASH(address) & 0x20) ==  0x20 );
  629. }