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