w90x950_12864lcdm

dingzerong

1. /*
   
2.  *
   
3.  * drivers/w90x950_12864lcdm.c
   
4.  *
   
5.  * (c) 2010 Adem Zhu<dengbo.zhu@gmail.com>
   
6.  *
   
7.  * W90x950 128X64 TN LCD pane Model driver
   
8.  *
   
9. */
   
10. 
    
11. #include <linux/module.h>
    
12. #include <linux/fs.h>
    
13. #include <linux/delay.h>
    
14. #include <asm/uaccess.h>
    
15. 
    
16. #include <asm/arch/hardware.h>
    
17. #include <asm/io.h>
    
18. 
    
19. #include <asm/arch/w90x900_reg.h>
    
20. 
    
21. #define    LCDM12864_MAJOR            (79)
    
22. #define DEV_NAME            "lcdm128x64"
    
23. 
    
24. #define LCDM12864_RESET            (0x00)
    
25. /* refrest LCDM, no arg */
    
26. 
    
27. #define    LCDM12864_REFRESH_BLOCK_IN_PAGE    (0x01)
    
28. /* arg is pointer of struct lcdm12864_refresh_block */
    
29. 
    
30. struct lcdm12864_refresh_block
    
31. {
    
32.     unsigned char page;
    
33.     unsigned char startx;
    
34.     unsigned char endx;
    
35.     unsigned char length;
    
36.     unsigned char *data;
    
37. };
    
38. 
    
39. #define LCDM12864_BACKLIGHT_CTRL    (0x02)
    
40. /* the LCDM backlight is on when arg is a non-zero value */
    
41. 
    
42. /*
    
43. hardware definitions.
    
44.     LCDM_CS        <=>        GPIO D2
    
45.     LCDM_RES    <=>        GPIO D3
    
46.     LCDM_A0        <=>        GPIO D0
    
47.     LCDM_SCK    <=>        GPIO D5
    
48.     LCDM_SDA    <=>        GPIO D6
    
49. 
    
50.     LCDM_BACKLIGHT    <=>        GPIO D1
    
51. */
    
52. 
    
53. static void hw_128X64_sendbyte(unsigned char db)
    
54. {
    
55.     long value;
    
56.     int index;
    
57.     for (index = 0; index < 8; index ++)
    
58.     {
    
59.         value = inl(REG_GPIOD_DATAOUT);
    
60.         value &= ~(1<<6);
    
61.         if (db & 0x80)
    
62.         {
    
63.             value |= (1<<6);
    
64.         }
    
65. 
    
66.         outl(value, REG_GPIOD_DATAOUT);    /* flush LCDM_SDA */
    
67. 
    
68.         outl(inl(REG_GPIOD_DATAOUT) & ~(1 << 5), REG_GPIOD_DATAOUT); /*clock down LCDM_SCK (GPIO D5)*/
    
69. 
    
70.         db <<= 1;
    
71. 
    
72.         outl(inl(REG_GPIOD_DATAOUT) | (1 << 5), REG_GPIOD_DATAOUT); /*clock up LCDM_SCK (GPIO D5)*/
    
73.     }
    
74. }
    
75. 
    
76. static void hw_128X64_init(void)
    
77. {
    
78.     outl(inl(REG_GPIOD_DATAOUT) | (1 << 5), REG_GPIOD_DATAOUT); /*default: clock up LCDM_SCK (GPIO D5)*/
    
79. 
    
80.     outl(inl(REG_GPIOD_DATAOUT) & ~(1 << 0), REG_GPIOD_DATAOUT); /*pull down LCDM_A0 (GPIO D0)*/
    
81. 
    
82.     outl(inl(REG_GPIOD_DATAOUT) & ~(1 << 2), REG_GPIOD_DATAOUT); /*pull down LCDM_CS (GPIO D2)*/
    
83. }
    
84. 
    
85. static void hw_128X64_reset(void) /* Reset the module */
    
86. {
    
87.     outl(inl(REG_GPIOD_DATAOUT) & ~(1 << 3), REG_GPIOD_DATAOUT); /*pull down LCDM_RES (GPIO D3)*/
    
88. 
    
89.     udelay(1000);
    
90. 
    
91.     outl(inl(REG_GPIOD_DATAOUT) | (1 << 3), REG_GPIOD_DATAOUT); /*pull up LCDM_RES (GPIO D3)*/
    
92. 
    
93.     udelay(1000);
    
94. }
    
95. 
    
96. static void hw_128X64_open(void)
    
97. {
    
98.     /* Booster ratio set : 5X */
    
99.     hw_128X64_sendbyte(0xf8);
    
100.     udelay(999);
     
101.     hw_128X64_sendbyte(0x01);
     
102.     udelay(999);
     
103. 
     
104.     /* Segment Driver Direction Select : Normal */
     
105.     hw_128X64_sendbyte(0xa0);
     
106.     udelay(999);
     
107. 
     
108.     /* Common Output Mode Select : Normal */
     
109.     hw_128X64_sendbyte(0xc0);
     
110.     udelay(999);
     
111. 
     
112.     /* LCD Bias Set : 1/65 duty, 1/9 bias */
     
113.     hw_128X64_sendbyte(0xa2);
     
114.     udelay(2000);
     
115. 
     
116.     /* power control set */
     
117.     hw_128X64_sendbyte(0x2c);
     
118.     udelay(2000);
     
119. 
     
120.     hw_128X64_sendbyte(0x2e);
     
121.     udelay(2000);
     
122. 
     
123.     hw_128X64_sendbyte(0x2f);
     
124.     udelay(2000);
     
125. 
     
126.     /* power control set */
     
127.     hw_128X64_sendbyte(0x25);
     
128.     udelay(999);
     
129. 
     
130.     /* The Electronic Volume Mode Set */
     
131.     hw_128X64_sendbyte(0x81);
     
132.     udelay(999);
     
133.     hw_128X64_sendbyte(34);
     
134.     udelay(999);
     
135. 
     
136.     /* Display all points off */
     
137.     hw_128X64_sendbyte(0xa4);
     
138.     udelay(999);
     
139. 
     
140.     /* Display ON mode */
     
141.     hw_128X64_sendbyte(0xaf);
     
142.     udelay(999);
     
143. }
     
144. 
     
145. static void hw_128X64_set_startline(unsigned char start_line)
     
146. {
     
147.     /* 0 1 Display start address */
     
148.     hw_128X64_sendbyte((start_line & 0x3f) | 0x40);
     
149. }
     
150. 
     
151. static void hw_128X64_set_page(unsigned char page)
     
152. {
     
153.     /* 1 0 1 1 page address */
     
154.     hw_128X64_sendbyte((page & 0x0f) | 0xb0);
     
155. }
     
156. 
     
157. static void hw_128X64_set_column(unsigned char column)
     
158. {
     
159.     /* 0 0 0 1 higher bits */
     
160.     hw_128X64_sendbyte(((column >> 4) & 0x0f) | 0x10);
     
161. 
     
162.     /* 0 0 0 0 lower bits */
     
163.     hw_128X64_sendbyte(column & 0x0f);
     
164. }
     
165. 
     
166. static void hw_128X64_writedata(unsigned char db)
     
167. {
     
168.     outl(inl(REG_GPIOD_DATAOUT) | (1 << 0), REG_GPIOD_DATAOUT); /*pull up LCDM_A0 (GPIO D0)*/
     
169. 
     
170.     /* data */
     
171.     hw_128X64_sendbyte(db);
     
172. 
     
173.     outl(inl(REG_GPIOD_DATAOUT) & ~(1 << 0), REG_GPIOD_DATAOUT); /*pull down LCDM_A0 (GPIO D0)*/
     
174. }
     
175. 
     
176. static void lcdm_reset(void) /* reset lcd model : init & reset & open & set_startline */
     
177. {
     
178.     hw_128X64_init();
     
179. 
     
180.     hw_128X64_reset();
     
181. 
     
182.     hw_128X64_open();
     
183. 
     
184.     hw_128X64_set_startline(0);
     
185. }
     
186. 
     
187. static void lcdm_refresh_block_in_page(unsigned char page, unsigned char startx, unsigned char endx, char * data)
     
188. {
     
189.     int cnt = (endx - startx + 1);
     
190. 
     
191.     hw_128X64_set_page(page);
     
192. 
     
193.     hw_128X64_set_column(startx);
     
194. 
     
195.     for (;cnt--;)
     
196.     {
     
197.         hw_128X64_writedata(*data ++);
     
198.     }
     
199. }
     
200. 
     
201. static int w90x950_12864lcdm_open(struct inode *inode, struct file *file)
     
202. {
     
203.     return 0;
     
204. }
     
205. 
     
206. static int w90x950_12864lcdm_close(struct inode *inode, struct file *file)
     
207. {
     
208.     return 0;
     
209. }
     
210. 
     
211. static int w90x950_12864lcdm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
     
212. {
     
213.     struct lcdm12864_refresh_block refresh_cmd;
     
214.     unsigned char *buf;
     
215. 
     
216.     switch (cmd)
     
217.     {
     
218.         case LCDM12864_RESET: /* reset lcd module */
     
219.             lcdm_reset();
     
220.             return 0;
     
221.             break;
     
222. 
     
223.         case LCDM12864_REFRESH_BLOCK_IN_PAGE:
     
224.             if (!arg)
     
225.                 return -EINVAL;
     
226. 
     
227.             if (copy_from_user(&refresh_cmd, (const void *)arg, sizeof(struct lcdm12864_refresh_block)))
     
228.                 return -EFAULT;
     
229. 
     
230.             if (refresh_cmd.length != refresh_cmd.endx - refresh_cmd.startx + 1)
     
231.                 return -EINVAL;
     
232. 
     
233.             /* allocate memory */
     
234.             buf = kzalloc(refresh_cmd.length, GFP_KERNEL);
     
235.             if (!buf)
     
236.                 return -ENOMEM;
     
237. 
     
238.             if (copy_from_user(buf, refresh_cmd.data, refresh_cmd.length))
     
239.             {
     
240.                 kfree(buf);
     
241.                 return -EFAULT;
     
242.             }
     
243. 
     
244.             lcdm_refresh_block_in_page(refresh_cmd.page, refresh_cmd.startx, refresh_cmd.endx, refresh_cmd.data);
     
245. 
     
246.             kfree(buf);
     
247.             return 0;
     
248.             break;
     
249. 
     
250.         case LCDM12864_BACKLIGHT_CTRL:
     
251.             if (arg)
     
252.             {
     
253.                 outl(inl(REG_GPIOD_DATAOUT) | (1 << 1), REG_GPIOD_DATAOUT); /*pull up LCDM_BACKLIGHT (GPIO D1)*/
     
254.             }
     
255.             else
     
256.             {
     
257.                 outl(inl(REG_GPIOD_DATAOUT) & ~(1 << 1), REG_GPIOD_DATAOUT); /*pull down LCDM_BACKLIGHT (GPIO D1)*/
     
258.             };
     
259.             return 0;
     
260.             break;
     
261.     }
     
262. 
     
263.     return -EINVAL;
     
264. }
     
265. 
     
266. struct file_operations w90x950_12864lcdm_fops =
     
267. {
     
268.     owner:      THIS_MODULE,
     
269.     open:     w90x950_12864lcdm_open,
     
270.     ioctl:     w90x950_12864lcdm_ioctl,
     
271.     release: w90x950_12864lcdm_close,
     
272. };
     
273. 
     
274. static int __init w90x950_12864lcdm_init(void)
     
275. {
     
276.     if (register_chrdev(LCDM12864_MAJOR, DEV_NAME, &w90x950_12864lcdm_fops) < 0)
     
277.     {
     
278.         printk("can't get major %d\n", LCDM12864_MAJOR);
     
279.         return -1;
     
280.     }
     
281. 
     
282.     /* config the all io pins (D0, D1, D2, D3, D5, D6) */
     
283.     outl(inl(REG_MFSEL) & ~0x00f0, REG_MFSEL);        /* configure GPIOD to IO function. */
     
284.     outl(inl(REG_GPIOD_DIR) | 0x006f, REG_GPIOD_DIR);    /* configure output pins. */
     
285.     outl(inl(REG_GPIODPE) | 0x006f, REG_GPIODPE);        /* configure pins as pullup. */
     
286. 
     
287.     lcdm_reset();
     
288. 
     
289.     printk("W90X950 128X64 TN LCDM driver started successfully!\n");
     
290. 
     
291.     return(0);
     
292. }
     
293. 
     
294. static void __exit w90x950_12864lcdm_exit(void)
     
295. {
     
296.     unregister_chrdev(LCDM12864_MAJOR, DEV_NAME);
     
297. }
     
298. 
     
299. module_init(w90x950_12864lcdm_init);
     
300. module_exit(w90x950_12864lcdm_exit);
     
301. 
     
302. MODULE_AUTHOR("Adem Zhu <dengbo.zhu@gmail.com>");
     
303. MODULE_DESCRIPTION("NUC950 128X64 TN LCD pane Model driver");
     
304. MODULE_LICENSE("GPL");