[package] 6in4, 6to4: prevent starting the tunnel if kmod-sit is not yet loaded ...
[openwrt.git] / target / linux / ubicom32 / files / drivers / video / backlight / ubicom32lcd.c
1 /*
2 * drivers/video/ubicom32lcd.c
3 * LCD initilization code
4 *
5 * (C) Copyright 2009, Ubicom, Inc.
6 *
7 * This file is part of the Ubicom32 Linux Kernel Port.
8 *
9 * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10 * it and/or modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation, either version 2 of the
12 * License, or (at your option) any later version.
13 *
14 * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with the Ubicom32 Linux Kernel Port. If not,
21 * see <http://www.gnu.org/licenses/>.
22 */
23 #include <linux/init.h>
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/platform_device.h>
27 #include <linux/delay.h>
28
29 #include <asm/ip5000.h>
30 #include <asm/gpio.h>
31 #include <asm/ubicom32lcd.h>
32
33 #include "ubicom32lcd.h"
34
35 #define DRIVER_NAME "ubicom32lcd"
36
37 struct ubicom32lcd_data {
38 const struct ubicom32lcd_panel *panel;
39
40 int pin_cs;
41 int pin_rd;
42 int pin_rs;
43 int pin_wr;
44 int pin_reset;
45 struct ubicom32_io_port *port_data;
46 int data_shift;
47 };
48
49 /*
50 * ubicom32lcd_write
51 * Performs a write cycle on the bus (assumes CS asserted, RD & WR set)
52 */
53 static void ubicom32lcd_write(struct ubicom32lcd_data *ud, int command, u16 data)
54 {
55 if (command) {
56 UBICOM32_GPIO_SET_PIN_LOW(ud->pin_rs);
57 } else {
58 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
59 }
60
61 asm volatile (
62 "or.4 4(%[port]), 4(%[port]), %[mask] \n\t"
63 "not.4 %[mask], %[mask] \n\t"
64 "and.4 8(%[port]), 8(%[port]), %[mask] \n\t"
65 "or.4 8(%[port]), 8(%[port]), %[cmd] \n\t"
66 :
67 : [port] "a" (ud->port_data),
68 [mask] "d" (0xFFFF << ud->data_shift),
69 [cmd] "d" (data << ud->data_shift)
70 : "cc"
71 );
72
73 UBICOM32_GPIO_SET_PIN_LOW(ud->pin_wr);
74
75 //ndelay(50);
76 udelay(1);
77
78 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_wr);
79
80 udelay(1);
81 //ndelay(50);
82 }
83
84 /*
85 * ubicom32lcd_read_data
86 * Performs a read cycle on the bus (assumes CS asserted, RD & WR set)
87 */
88 static u16 ubicom32lcd_read_data(struct ubicom32lcd_data *ud)
89 {
90 u32_t data;
91
92 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
93
94 asm volatile (
95 "and.4 4(%[port]), 4(%[port]), %[mask]\n\t"
96 :
97 : [port] "a" (ud->port_data),
98 [mask] "d" (~(0xFFFF << ud->data_shift))
99 : "cc"
100 );
101
102 UBICOM32_GPIO_SET_PIN_LOW(ud->pin_rd);
103
104 ndelay(300);
105
106 asm volatile (
107 "lsr.4 %[data], 12(%[port]), %[shamt] \n\t"
108 "and.4 %[data], %[data], %[mask] \n\t"
109 : [data] "=d" (data)
110 : [port] "a" (ud->port_data),
111 [mask] "d" (0xFFFF),
112 [shamt] "d" (ud->data_shift)
113 : "cc"
114 );
115
116 ndelay(200);
117
118 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rd);
119
120 ndelay(500);
121
122 return data;
123 }
124
125 /*
126 * ubicom32lcd_execute
127 * Executes a script for performing operations on the LCD (assumes CS set)
128 */
129 static void ubicom32lcd_execute(struct ubicom32lcd_data *ud, const struct ubicom32lcd_step *script)
130 {
131 while (1) {
132 switch (script->op) {
133 case LCD_STEP_CMD:
134 ubicom32lcd_write(ud, 1, script->cmd);
135 break;
136
137 case LCD_STEP_DATA:
138 ubicom32lcd_write(ud, 0, script->data);
139 break;
140
141 case LCD_STEP_CMD_DATA:
142 ubicom32lcd_write(ud, 1, script->cmd);
143 ubicom32lcd_write(ud, 0, script->data);
144 break;
145
146 case LCD_STEP_SLEEP:
147 udelay(script->data);
148 break;
149
150 case LCD_STEP_DONE:
151 return;
152 }
153 script++;
154 }
155 }
156
157 /*
158 * ubicom32lcd_goto
159 * Places the gram pointer at a specific X, Y address
160 */
161 static void ubicom32lcd_goto(struct ubicom32lcd_data *ud, int x, int y)
162 {
163 ubicom32lcd_write(ud, 1, ud->panel->horz_reg);
164 ubicom32lcd_write(ud, 0, x);
165 ubicom32lcd_write(ud, 1, ud->panel->vert_reg);
166 ubicom32lcd_write(ud, 0, y);
167 ubicom32lcd_write(ud, 1, ud->panel->gram_reg);
168 }
169
170 /*
171 * ubicom32lcd_panel_init
172 * Initializes the lcd panel.
173 */
174 static int ubicom32lcd_panel_init(struct ubicom32lcd_data *ud)
175 {
176 u16 id;
177
178 UBICOM32_GPIO_SET_PIN_LOW(ud->pin_reset);
179 UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_reset);
180 UBICOM32_GPIO_ENABLE(ud->pin_reset);
181
182 asm volatile (
183 "or.4 0x50(%[port]), 0x50(%[port]), %[mask] \n\t"
184 "not.4 %[mask], %[mask] \n\t"
185 "and.4 0x04(%[port]), 0x04(%[port]), %[mask] \n\t"
186 :
187 : [port] "a" (ud->port_data),
188 [mask] "d" (0xFFFF << ud->data_shift)
189 : "cc"
190 );
191
192 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
193 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rd);
194 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_wr);
195 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_cs);
196
197 UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_rs);
198 UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_rd);
199 UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_wr);
200 UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_cs);
201
202 UBICOM32_GPIO_ENABLE(ud->pin_rs);
203 UBICOM32_GPIO_ENABLE(ud->pin_rd);
204 UBICOM32_GPIO_ENABLE(ud->pin_wr);
205 UBICOM32_GPIO_ENABLE(ud->pin_cs);
206
207 udelay(20);
208
209 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_reset);
210
211 udelay(20);
212
213 UBICOM32_GPIO_SET_PIN_LOW(ud->pin_cs);
214
215 id = ubicom32lcd_read_data(ud);
216
217 /*
218 * We will try to figure out what kind of panel we have if we were not told.
219 */
220 if (!ud->panel) {
221 const struct ubicom32lcd_panel **p = ubicom32lcd_panels;
222 while (*p) {
223 if ((*p)->id && ((*p)->id == id)) {
224 break;
225 }
226 p++;
227 }
228 if (!*p) {
229 printk(KERN_WARNING DRIVER_NAME ":Could not find compatible panel, id=%x\n", id);
230 return -ENODEV;
231 }
232 ud->panel = *p;
233 }
234
235 /*
236 * Make sure panel ID matches if we were supplied a panel type
237 */
238 if (ud->panel->id && (ud->panel->id != id)) {
239 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_cs);
240
241 return -ENODEV;
242 }
243
244 ubicom32lcd_execute(ud, ud->panel->init_seq);
245
246 ubicom32lcd_goto(ud, 0, 0);
247
248 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_cs);
249 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rd);
250 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_wr);
251 UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
252
253 printk(KERN_INFO DRIVER_NAME ": Initialized panel %s\n", ud->panel->desc);
254
255 return 0;
256 }
257
258 /*
259 * ubicom32lcd_probe
260 */
261 static int ubicom32lcd_probe(struct platform_device *pdev)
262 {
263 const struct ubicom32lcd_platform_data *pdata = pdev->dev.platform_data;
264 struct ubicom32lcd_data *ud;
265 int retval;
266
267 /*
268 * Allocate our private data
269 */
270 ud = kzalloc(sizeof(struct ubicom32lcd_data), GFP_KERNEL);
271 if (!ud) {
272 return -ENOMEM;
273 }
274
275 if (pdata) {
276 ud->pin_cs = pdata->pin_cs;
277 ud->pin_rd = pdata->pin_rd;
278 ud->pin_wr = pdata->pin_wr;
279 ud->pin_rs = pdata->pin_rs;
280 ud->pin_reset = pdata->pin_reset;
281 ud->port_data = pdata->port_data;
282 ud->data_shift = pdata->data_shift;
283 } else {
284 /*
285 * Defaults
286 */
287 ud->pin_cs = GPIO_RD_4;
288 ud->pin_rd = GPIO_RD_5;
289 ud->pin_rs = GPIO_RD_3;
290 ud->pin_wr = GPIO_RD_2;
291 ud->pin_reset = GPIO_RD_7;
292 ud->port_data = (struct ubicom32_io_port *)RI;
293 ud->data_shift = 0;
294 }
295
296 /*
297 * Initialize the display
298 */
299 retval = ubicom32lcd_panel_init(ud);
300 if (retval) {
301 kfree(ud);
302 return retval;
303 }
304
305 printk(KERN_INFO DRIVER_NAME ": LCD initialized\n");
306
307 return 0;
308 }
309
310 /*
311 * ubicom32lcd_remove
312 */
313 static int __exit ubicom32lcd_remove(struct platform_device *pdev)
314 {
315 struct ubicom32lcd_data *ud = platform_get_drvdata(pdev);
316
317 kfree(ud);
318
319 return 0;
320 }
321
322 static struct platform_driver ubicom32lcd_driver = {
323 .probe = ubicom32lcd_probe,
324 .remove = ubicom32lcd_remove,
325
326 .driver = {
327 .name = DRIVER_NAME,
328 .owner = THIS_MODULE,
329 },
330
331 .remove = __exit_p(ubicom32lcd_remove),
332 };
333
334 static struct platform_device *ubicom32lcd_device;
335
336 /*
337 * ubicom32lcd_init
338 */
339 static int __init ubicom32lcd_init(void)
340 {
341 int res;
342
343 res = platform_driver_register(&ubicom32lcd_driver);
344 if (res == 0) {
345 ubicom32lcd_device = platform_device_alloc(DRIVER_NAME, 0);
346 if (ubicom32lcd_device) {
347 res = platform_device_add(ubicom32lcd_device);
348 } else {
349 res = -ENOMEM;
350 }
351 if (res) {
352 platform_device_put(ubicom32lcd_device);
353 platform_driver_unregister(&ubicom32lcd_driver);
354 }
355 }
356 return res;
357 }
358 module_init(ubicom32lcd_init);
359
360 /*
361 * ubicom32lcd_exit
362 */
363 static void __exit ubicom32lcd_exit(void)
364 {
365 platform_device_unregister(ubicom32lcd_device);
366 platform_driver_unregister(&ubicom32lcd_driver);
367 }
368 module_exit(ubicom32lcd_exit);
369
370 MODULE_AUTHOR("Patrick Tjin <@ubicom.com>");
371 MODULE_DESCRIPTION("Ubicom32 LCD driver");
372 MODULE_LICENSE("GPL");
This page took 0.078447 seconds and 5 git commands to generate.