373 lines
8.0 KiB
C
373 lines
8.0 KiB
C
/*
|
|
* drivers/video/ubicom32lcd.c
|
|
* LCD initilization code
|
|
*
|
|
* (C) Copyright 2009, Ubicom, Inc.
|
|
*
|
|
* This file is part of the Ubicom32 Linux Kernel Port.
|
|
*
|
|
* The Ubicom32 Linux Kernel Port is free software: you can redistribute
|
|
* it and/or modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation, either version 2 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* The Ubicom32 Linux Kernel Port is distributed in the hope that it
|
|
* will be useful, but WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
|
|
* the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with the Ubicom32 Linux Kernel Port. If not,
|
|
* see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/delay.h>
|
|
|
|
#include <asm/ip5000.h>
|
|
#include <asm/gpio.h>
|
|
#include <asm/ubicom32lcd.h>
|
|
|
|
#include "ubicom32lcd.h"
|
|
|
|
#define DRIVER_NAME "ubicom32lcd"
|
|
|
|
struct ubicom32lcd_data {
|
|
const struct ubicom32lcd_panel *panel;
|
|
|
|
int pin_cs;
|
|
int pin_rd;
|
|
int pin_rs;
|
|
int pin_wr;
|
|
int pin_reset;
|
|
struct ubicom32_io_port *port_data;
|
|
int data_shift;
|
|
};
|
|
|
|
/*
|
|
* ubicom32lcd_write
|
|
* Performs a write cycle on the bus (assumes CS asserted, RD & WR set)
|
|
*/
|
|
static void ubicom32lcd_write(struct ubicom32lcd_data *ud, int command, u16 data)
|
|
{
|
|
if (command) {
|
|
UBICOM32_GPIO_SET_PIN_LOW(ud->pin_rs);
|
|
} else {
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
|
|
}
|
|
|
|
asm volatile (
|
|
"or.4 4(%[port]), 4(%[port]), %[mask] \n\t"
|
|
"not.4 %[mask], %[mask] \n\t"
|
|
"and.4 8(%[port]), 8(%[port]), %[mask] \n\t"
|
|
"or.4 8(%[port]), 8(%[port]), %[cmd] \n\t"
|
|
:
|
|
: [port] "a" (ud->port_data),
|
|
[mask] "d" (0xFFFF << ud->data_shift),
|
|
[cmd] "d" (data << ud->data_shift)
|
|
: "cc"
|
|
);
|
|
|
|
UBICOM32_GPIO_SET_PIN_LOW(ud->pin_wr);
|
|
|
|
//ndelay(50);
|
|
udelay(1);
|
|
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_wr);
|
|
|
|
udelay(1);
|
|
//ndelay(50);
|
|
}
|
|
|
|
/*
|
|
* ubicom32lcd_read_data
|
|
* Performs a read cycle on the bus (assumes CS asserted, RD & WR set)
|
|
*/
|
|
static u16 ubicom32lcd_read_data(struct ubicom32lcd_data *ud)
|
|
{
|
|
u32_t data;
|
|
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
|
|
|
|
asm volatile (
|
|
"and.4 4(%[port]), 4(%[port]), %[mask]\n\t"
|
|
:
|
|
: [port] "a" (ud->port_data),
|
|
[mask] "d" (~(0xFFFF << ud->data_shift))
|
|
: "cc"
|
|
);
|
|
|
|
UBICOM32_GPIO_SET_PIN_LOW(ud->pin_rd);
|
|
|
|
ndelay(300);
|
|
|
|
asm volatile (
|
|
"lsr.4 %[data], 12(%[port]), %[shamt] \n\t"
|
|
"and.4 %[data], %[data], %[mask] \n\t"
|
|
: [data] "=d" (data)
|
|
: [port] "a" (ud->port_data),
|
|
[mask] "d" (0xFFFF),
|
|
[shamt] "d" (ud->data_shift)
|
|
: "cc"
|
|
);
|
|
|
|
ndelay(200);
|
|
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rd);
|
|
|
|
ndelay(500);
|
|
|
|
return data;
|
|
}
|
|
|
|
/*
|
|
* ubicom32lcd_execute
|
|
* Executes a script for performing operations on the LCD (assumes CS set)
|
|
*/
|
|
static void ubicom32lcd_execute(struct ubicom32lcd_data *ud, const struct ubicom32lcd_step *script)
|
|
{
|
|
while (1) {
|
|
switch (script->op) {
|
|
case LCD_STEP_CMD:
|
|
ubicom32lcd_write(ud, 1, script->cmd);
|
|
break;
|
|
|
|
case LCD_STEP_DATA:
|
|
ubicom32lcd_write(ud, 0, script->data);
|
|
break;
|
|
|
|
case LCD_STEP_CMD_DATA:
|
|
ubicom32lcd_write(ud, 1, script->cmd);
|
|
ubicom32lcd_write(ud, 0, script->data);
|
|
break;
|
|
|
|
case LCD_STEP_SLEEP:
|
|
udelay(script->data);
|
|
break;
|
|
|
|
case LCD_STEP_DONE:
|
|
return;
|
|
}
|
|
script++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* ubicom32lcd_goto
|
|
* Places the gram pointer at a specific X, Y address
|
|
*/
|
|
static void ubicom32lcd_goto(struct ubicom32lcd_data *ud, int x, int y)
|
|
{
|
|
ubicom32lcd_write(ud, 1, ud->panel->horz_reg);
|
|
ubicom32lcd_write(ud, 0, x);
|
|
ubicom32lcd_write(ud, 1, ud->panel->vert_reg);
|
|
ubicom32lcd_write(ud, 0, y);
|
|
ubicom32lcd_write(ud, 1, ud->panel->gram_reg);
|
|
}
|
|
|
|
/*
|
|
* ubicom32lcd_panel_init
|
|
* Initializes the lcd panel.
|
|
*/
|
|
static int ubicom32lcd_panel_init(struct ubicom32lcd_data *ud)
|
|
{
|
|
u16 id;
|
|
|
|
UBICOM32_GPIO_SET_PIN_LOW(ud->pin_reset);
|
|
UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_reset);
|
|
UBICOM32_GPIO_ENABLE(ud->pin_reset);
|
|
|
|
asm volatile (
|
|
"or.4 0x50(%[port]), 0x50(%[port]), %[mask] \n\t"
|
|
"not.4 %[mask], %[mask] \n\t"
|
|
"and.4 0x04(%[port]), 0x04(%[port]), %[mask] \n\t"
|
|
:
|
|
: [port] "a" (ud->port_data),
|
|
[mask] "d" (0xFFFF << ud->data_shift)
|
|
: "cc"
|
|
);
|
|
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rd);
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_wr);
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_cs);
|
|
|
|
UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_rs);
|
|
UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_rd);
|
|
UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_wr);
|
|
UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_cs);
|
|
|
|
UBICOM32_GPIO_ENABLE(ud->pin_rs);
|
|
UBICOM32_GPIO_ENABLE(ud->pin_rd);
|
|
UBICOM32_GPIO_ENABLE(ud->pin_wr);
|
|
UBICOM32_GPIO_ENABLE(ud->pin_cs);
|
|
|
|
udelay(20);
|
|
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_reset);
|
|
|
|
udelay(20);
|
|
|
|
UBICOM32_GPIO_SET_PIN_LOW(ud->pin_cs);
|
|
|
|
id = ubicom32lcd_read_data(ud);
|
|
|
|
/*
|
|
* We will try to figure out what kind of panel we have if we were not told.
|
|
*/
|
|
if (!ud->panel) {
|
|
const struct ubicom32lcd_panel **p = ubicom32lcd_panels;
|
|
while (*p) {
|
|
if ((*p)->id && ((*p)->id == id)) {
|
|
break;
|
|
}
|
|
p++;
|
|
}
|
|
if (!*p) {
|
|
printk(KERN_WARNING DRIVER_NAME ":Could not find compatible panel, id=%x\n", id);
|
|
return -ENODEV;
|
|
}
|
|
ud->panel = *p;
|
|
}
|
|
|
|
/*
|
|
* Make sure panel ID matches if we were supplied a panel type
|
|
*/
|
|
if (ud->panel->id && (ud->panel->id != id)) {
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_cs);
|
|
|
|
return -ENODEV;
|
|
}
|
|
|
|
ubicom32lcd_execute(ud, ud->panel->init_seq);
|
|
|
|
ubicom32lcd_goto(ud, 0, 0);
|
|
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_cs);
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rd);
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_wr);
|
|
UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
|
|
|
|
printk(KERN_INFO DRIVER_NAME ": Initialized panel %s\n", ud->panel->desc);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* ubicom32lcd_probe
|
|
*/
|
|
static int ubicom32lcd_probe(struct platform_device *pdev)
|
|
{
|
|
const struct ubicom32lcd_platform_data *pdata = pdev->dev.platform_data;
|
|
struct ubicom32lcd_data *ud;
|
|
int retval;
|
|
|
|
/*
|
|
* Allocate our private data
|
|
*/
|
|
ud = kzalloc(sizeof(struct ubicom32lcd_data), GFP_KERNEL);
|
|
if (!ud) {
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if (pdata) {
|
|
ud->pin_cs = pdata->pin_cs;
|
|
ud->pin_rd = pdata->pin_rd;
|
|
ud->pin_wr = pdata->pin_wr;
|
|
ud->pin_rs = pdata->pin_rs;
|
|
ud->pin_reset = pdata->pin_reset;
|
|
ud->port_data = pdata->port_data;
|
|
ud->data_shift = pdata->data_shift;
|
|
} else {
|
|
/*
|
|
* Defaults
|
|
*/
|
|
ud->pin_cs = GPIO_RD_4;
|
|
ud->pin_rd = GPIO_RD_5;
|
|
ud->pin_rs = GPIO_RD_3;
|
|
ud->pin_wr = GPIO_RD_2;
|
|
ud->pin_reset = GPIO_RD_7;
|
|
ud->port_data = (struct ubicom32_io_port *)RI;
|
|
ud->data_shift = 0;
|
|
}
|
|
|
|
/*
|
|
* Initialize the display
|
|
*/
|
|
retval = ubicom32lcd_panel_init(ud);
|
|
if (retval) {
|
|
kfree(ud);
|
|
return retval;
|
|
}
|
|
|
|
printk(KERN_INFO DRIVER_NAME ": LCD initialized\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* ubicom32lcd_remove
|
|
*/
|
|
static int __exit ubicom32lcd_remove(struct platform_device *pdev)
|
|
{
|
|
struct ubicom32lcd_data *ud = platform_get_drvdata(pdev);
|
|
|
|
kfree(ud);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_driver ubicom32lcd_driver = {
|
|
.probe = ubicom32lcd_probe,
|
|
.remove = ubicom32lcd_remove,
|
|
|
|
.driver = {
|
|
.name = DRIVER_NAME,
|
|
.owner = THIS_MODULE,
|
|
},
|
|
|
|
.remove = __exit_p(ubicom32lcd_remove),
|
|
};
|
|
|
|
static struct platform_device *ubicom32lcd_device;
|
|
|
|
/*
|
|
* ubicom32lcd_init
|
|
*/
|
|
static int __init ubicom32lcd_init(void)
|
|
{
|
|
int res;
|
|
|
|
res = platform_driver_register(&ubicom32lcd_driver);
|
|
if (res == 0) {
|
|
ubicom32lcd_device = platform_device_alloc(DRIVER_NAME, 0);
|
|
if (ubicom32lcd_device) {
|
|
res = platform_device_add(ubicom32lcd_device);
|
|
} else {
|
|
res = -ENOMEM;
|
|
}
|
|
if (res) {
|
|
platform_device_put(ubicom32lcd_device);
|
|
platform_driver_unregister(&ubicom32lcd_driver);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
module_init(ubicom32lcd_init);
|
|
|
|
/*
|
|
* ubicom32lcd_exit
|
|
*/
|
|
static void __exit ubicom32lcd_exit(void)
|
|
{
|
|
platform_device_unregister(ubicom32lcd_device);
|
|
platform_driver_unregister(&ubicom32lcd_driver);
|
|
}
|
|
module_exit(ubicom32lcd_exit);
|
|
|
|
MODULE_AUTHOR("Patrick Tjin <@ubicom.com>");
|
|
MODULE_DESCRIPTION("Ubicom32 LCD driver");
|
|
MODULE_LICENSE("GPL");
|