Root/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
37struct 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 */
53static 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 */
88static 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 */
129static 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 */
161static 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 */
174static 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 */
261static 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 */
313static 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
322static 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
334static struct platform_device *ubicom32lcd_device;
335
336/*
337 * ubicom32lcd_init
338 */
339static 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}
358module_init(ubicom32lcd_init);
359
360/*
361 * ubicom32lcd_exit
362 */
363static void __exit ubicom32lcd_exit(void)
364{
365    platform_device_unregister(ubicom32lcd_device);
366    platform_driver_unregister(&ubicom32lcd_driver);
367}
368module_exit(ubicom32lcd_exit);
369
370MODULE_AUTHOR("Patrick Tjin <@ubicom.com>");
371MODULE_DESCRIPTION("Ubicom32 LCD driver");
372MODULE_LICENSE("GPL");
373

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive