1 /*
2  *    Filename: cfag12864b.c
3  *     Version: 0.1.0
4  * Description: cfag12864b LCD driver
5  *     License: GPLv2
6  *     Depends: ks0108
7  *
8  *      Author: Copyright (C) Miguel Ojeda Sandonis
9  *        Date: 2006-10-31
10  *
11  *  This program is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License version 2 as
13  *  published by the Free Software Foundation.
14  *
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *  GNU General Public License for more details.
19  *
20  *  You should have received a copy of the GNU General Public License
21  *  along with this program; if not, write to the Free Software
22  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23  *
24  */
25 
26 #include <linux/init.h>
27 #include <linux/module.h>
28 #include <linux/kernel.h>
29 #include <linux/fs.h>
30 #include <linux/slab.h>
31 #include <linux/cdev.h>
32 #include <linux/delay.h>
33 #include <linux/device.h>
34 #include <linux/jiffies.h>
35 #include <linux/mutex.h>
36 #include <linux/uaccess.h>
37 #include <linux/vmalloc.h>
38 #include <linux/workqueue.h>
39 #include <linux/ks0108.h>
40 #include <linux/cfag12864b.h>
41 
42 
43 #define CFAG12864B_NAME "cfag12864b"
44 
45 /*
46  * Module Parameters
47  */
48 
49 static unsigned int cfag12864b_rate = CONFIG_CFAG12864B_RATE;
50 module_param(cfag12864b_rate, uint, S_IRUGO);
51 MODULE_PARM_DESC(cfag12864b_rate,
52 	"Refresh rate (hertz)");
53 
54 unsigned int cfag12864b_getrate(void)
55 {
56 	return cfag12864b_rate;
57 }
58 
59 /*
60  * cfag12864b Commands
61  *
62  *	E = Enable signal
63  *		Every time E switch from low to high,
64  *		cfag12864b/ks0108 reads the command/data.
65  *
66  *	CS1 = First ks0108controller.
67  *		If high, the first ks0108 controller receives commands/data.
68  *
69  *	CS2 = Second ks0108 controller
70  *		If high, the second ks0108 controller receives commands/data.
71  *
72  *	DI = Data/Instruction
73  *		If low, cfag12864b will expect commands.
74  *		If high, cfag12864b will expect data.
75  *
76  */
77 
78 #define bit(n) (((unsigned char)1)<<(n))
79 
80 #define CFAG12864B_BIT_E	(0)
81 #define CFAG12864B_BIT_CS1	(2)
82 #define CFAG12864B_BIT_CS2	(1)
83 #define CFAG12864B_BIT_DI	(3)
84 
85 static unsigned char cfag12864b_state;
86 
87 static void cfag12864b_set(void)
88 {
89 	ks0108_writecontrol(cfag12864b_state);
90 }
91 
92 static void cfag12864b_setbit(unsigned char state, unsigned char n)
93 {
94 	if (state)
95 		cfag12864b_state |= bit(n);
96 	else
97 		cfag12864b_state &= ~bit(n);
98 }
99 
100 static void cfag12864b_e(unsigned char state)
101 {
102 	cfag12864b_setbit(state, CFAG12864B_BIT_E);
103 	cfag12864b_set();
104 }
105 
106 static void cfag12864b_cs1(unsigned char state)
107 {
108 	cfag12864b_setbit(state, CFAG12864B_BIT_CS1);
109 }
110 
111 static void cfag12864b_cs2(unsigned char state)
112 {
113 	cfag12864b_setbit(state, CFAG12864B_BIT_CS2);
114 }
115 
116 static void cfag12864b_di(unsigned char state)
117 {
118 	cfag12864b_setbit(state, CFAG12864B_BIT_DI);
119 }
120 
121 static void cfag12864b_setcontrollers(unsigned char first,
122 	unsigned char second)
123 {
124 	if (first)
125 		cfag12864b_cs1(0);
126 	else
127 		cfag12864b_cs1(1);
128 
129 	if (second)
130 		cfag12864b_cs2(0);
131 	else
132 		cfag12864b_cs2(1);
133 }
134 
135 static void cfag12864b_controller(unsigned char which)
136 {
137 	if (which == 0)
138 		cfag12864b_setcontrollers(1, 0);
139 	else if (which == 1)
140 		cfag12864b_setcontrollers(0, 1);
141 }
142 
143 static void cfag12864b_displaystate(unsigned char state)
144 {
145 	cfag12864b_di(0);
146 	cfag12864b_e(1);
147 	ks0108_displaystate(state);
148 	cfag12864b_e(0);
149 }
150 
151 static void cfag12864b_address(unsigned char address)
152 {
153 	cfag12864b_di(0);
154 	cfag12864b_e(1);
155 	ks0108_address(address);
156 	cfag12864b_e(0);
157 }
158 
159 static void cfag12864b_page(unsigned char page)
160 {
161 	cfag12864b_di(0);
162 	cfag12864b_e(1);
163 	ks0108_page(page);
164 	cfag12864b_e(0);
165 }
166 
167 static void cfag12864b_startline(unsigned char startline)
168 {
169 	cfag12864b_di(0);
170 	cfag12864b_e(1);
171 	ks0108_startline(startline);
172 	cfag12864b_e(0);
173 }
174 
175 static void cfag12864b_writebyte(unsigned char byte)
176 {
177 	cfag12864b_di(1);
178 	cfag12864b_e(1);
179 	ks0108_writedata(byte);
180 	cfag12864b_e(0);
181 }
182 
183 static void cfag12864b_nop(void)
184 {
185 	cfag12864b_startline(0);
186 }
187 
188 /*
189  * cfag12864b Internal Commands
190  */
191 
192 static void cfag12864b_on(void)
193 {
194 	cfag12864b_setcontrollers(1, 1);
195 	cfag12864b_displaystate(1);
196 }
197 
198 static void cfag12864b_off(void)
199 {
200 	cfag12864b_setcontrollers(1, 1);
201 	cfag12864b_displaystate(0);
202 }
203 
204 static void cfag12864b_clear(void)
205 {
206 	unsigned char i, j;
207 
208 	cfag12864b_setcontrollers(1, 1);
209 	for (i = 0; i < CFAG12864B_PAGES; i++) {
210 		cfag12864b_page(i);
211 		cfag12864b_address(0);
212 		for (j = 0; j < CFAG12864B_ADDRESSES; j++)
213 			cfag12864b_writebyte(0);
214 	}
215 }
216 
217 /*
218  * Update work
219  */
220 
221 unsigned char *cfag12864b_buffer;
222 static unsigned char *cfag12864b_cache;
223 static DEFINE_MUTEX(cfag12864b_mutex);
224 static unsigned char cfag12864b_updating;
225 static void cfag12864b_update(struct work_struct *delayed_work);
226 static struct workqueue_struct *cfag12864b_workqueue;
227 static DECLARE_DELAYED_WORK(cfag12864b_work, cfag12864b_update);
228 
229 static void cfag12864b_queue(void)
230 {
231 	queue_delayed_work(cfag12864b_workqueue, &cfag12864b_work,
232 		HZ / cfag12864b_rate);
233 }
234 
235 unsigned char cfag12864b_enable(void)
236 {
237 	unsigned char ret;
238 
239 	mutex_lock(&cfag12864b_mutex);
240 
241 	if (!cfag12864b_updating) {
242 		cfag12864b_updating = 1;
243 		cfag12864b_queue();
244 		ret = 0;
245 	} else
246 		ret = 1;
247 
248 	mutex_unlock(&cfag12864b_mutex);
249 
250 	return ret;
251 }
252 
253 void cfag12864b_disable(void)
254 {
255 	mutex_lock(&cfag12864b_mutex);
256 
257 	if (cfag12864b_updating) {
258 		cfag12864b_updating = 0;
259 		cancel_delayed_work(&cfag12864b_work);
260 		flush_workqueue(cfag12864b_workqueue);
261 	}
262 
263 	mutex_unlock(&cfag12864b_mutex);
264 }
265 
266 unsigned char cfag12864b_isenabled(void)
267 {
268 	return cfag12864b_updating;
269 }
270 
271 static void cfag12864b_update(struct work_struct *work)
272 {
273 	unsigned char c;
274 	unsigned short i, j, k, b;
275 
276 	if (memcmp(cfag12864b_cache, cfag12864b_buffer, CFAG12864B_SIZE)) {
277 		for (i = 0; i < CFAG12864B_CONTROLLERS; i++) {
278 			cfag12864b_controller(i);
279 			cfag12864b_nop();
280 			for (j = 0; j < CFAG12864B_PAGES; j++) {
281 				cfag12864b_page(j);
282 				cfag12864b_nop();
283 				cfag12864b_address(0);
284 				cfag12864b_nop();
285 				for (k = 0; k < CFAG12864B_ADDRESSES; k++) {
286 					for (c = 0, b = 0; b < 8; b++)
287 						if (cfag12864b_buffer
288 							[i * CFAG12864B_ADDRESSES / 8
289 							+ k / 8 + (j * 8 + b) *
290 							CFAG12864B_WIDTH / 8]
291 							& bit(k % 8))
292 							c |= bit(b);
293 					cfag12864b_writebyte(c);
294 				}
295 			}
296 		}
297 
298 		memcpy(cfag12864b_cache, cfag12864b_buffer, CFAG12864B_SIZE);
299 	}
300 
301 	if (cfag12864b_updating)
302 		cfag12864b_queue();
303 }
304 
305 /*
306  * cfag12864b Exported Symbols
307  */
308 
309 EXPORT_SYMBOL_GPL(cfag12864b_buffer);
310 EXPORT_SYMBOL_GPL(cfag12864b_getrate);
311 EXPORT_SYMBOL_GPL(cfag12864b_enable);
312 EXPORT_SYMBOL_GPL(cfag12864b_disable);
313 EXPORT_SYMBOL_GPL(cfag12864b_isenabled);
314 
315 /*
316  * Is the module inited?
317  */
318 
319 static unsigned char cfag12864b_inited;
320 unsigned char cfag12864b_isinited(void)
321 {
322 	return cfag12864b_inited;
323 }
324 EXPORT_SYMBOL_GPL(cfag12864b_isinited);
325 
326 /*
327  * Module Init & Exit
328  */
329 
330 static int __init cfag12864b_init(void)
331 {
332 	int ret = -EINVAL;
333 
334 	/* ks0108_init() must be called first */
335 	if (!ks0108_isinited()) {
336 		printk(KERN_ERR CFAG12864B_NAME ": ERROR: "
337 			"ks0108 is not initialized\n");
338 		goto none;
339 	}
340 	BUILD_BUG_ON(PAGE_SIZE < CFAG12864B_SIZE);
341 
342 	cfag12864b_buffer = (unsigned char *) get_zeroed_page(GFP_KERNEL);
343 	if (cfag12864b_buffer == NULL) {
344 		printk(KERN_ERR CFAG12864B_NAME ": ERROR: "
345 			"can't get a free page\n");
346 		ret = -ENOMEM;
347 		goto none;
348 	}
349 
350 	cfag12864b_cache = kmalloc(sizeof(unsigned char) *
351 		CFAG12864B_SIZE, GFP_KERNEL);
352 	if (cfag12864b_cache == NULL) {
353 		printk(KERN_ERR CFAG12864B_NAME ": ERROR: "
354 			"can't alloc cache buffer (%i bytes)\n",
355 			CFAG12864B_SIZE);
356 		ret = -ENOMEM;
357 		goto bufferalloced;
358 	}
359 
360 	cfag12864b_workqueue = create_singlethread_workqueue(CFAG12864B_NAME);
361 	if (cfag12864b_workqueue == NULL)
362 		goto cachealloced;
363 
364 	cfag12864b_clear();
365 	cfag12864b_on();
366 
367 	cfag12864b_inited = 1;
368 	return 0;
369 
370 cachealloced:
371 	kfree(cfag12864b_cache);
372 
373 bufferalloced:
374 	free_page((unsigned long) cfag12864b_buffer);
375 
376 none:
377 	return ret;
378 }
379 
380 static void __exit cfag12864b_exit(void)
381 {
382 	cfag12864b_disable();
383 	cfag12864b_off();
384 	destroy_workqueue(cfag12864b_workqueue);
385 	kfree(cfag12864b_cache);
386 	free_page((unsigned long) cfag12864b_buffer);
387 }
388 
389 module_init(cfag12864b_init);
390 module_exit(cfag12864b_exit);
391 
392 MODULE_LICENSE("GPL v2");
393 MODULE_AUTHOR("Miguel Ojeda Sandonis <miguel.ojeda.sandonis@gmail.com>");
394 MODULE_DESCRIPTION("cfag12864b LCD driver");
395