sh_mobile_lcdcfb.c revision ce1c0b0873bf4e970970a49612105cf6c36d81e3
141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham/* 241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * SuperH Mobile LCDC Framebuffer 341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * 441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * Copyright (c) 2008 Magnus Damm 541e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * 641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * This file is subject to the terms and conditions of the GNU General Public 741e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * License. See the file "COPYING" in the main directory of this archive 841e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * for more details. 941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham */ 1041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 1141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include <linux/kernel.h> 1241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include <linux/init.h> 1341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include <linux/delay.h> 1441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include <linux/mm.h> 1541e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include <linux/clk.h> 1641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include <linux/pm_runtime.h> 1741e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include <linux/platform_device.h> 1841e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include <linux/dma-mapping.h> 1941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include <linux/interrupt.h> 20b3b961448f702339444036f94252ff2ba7a99febManu Abraham#include <linux/vmalloc.h> 2141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include <linux/ioctl.h> 22b3b961448f702339444036f94252ff2ba7a99febManu Abraham#include <linux/slab.h> 23b3b961448f702339444036f94252ff2ba7a99febManu Abraham#include <linux/console.h> 24b3b961448f702339444036f94252ff2ba7a99febManu Abraham#include <linux/backlight.h> 25b3b961448f702339444036f94252ff2ba7a99febManu Abraham#include <linux/gpio.h> 26b3b961448f702339444036f94252ff2ba7a99febManu Abraham#include <video/sh_mobile_lcdc.h> 27b3b961448f702339444036f94252ff2ba7a99febManu Abraham#include <linux/atomic.h> 2841e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 2941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include "sh_mobile_lcdcfb.h" 3041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#include "sh_mobile_meram.h" 3141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 3241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#define SIDE_B_OFFSET 0x1000 33b3b961448f702339444036f94252ff2ba7a99febManu Abraham#define MIRROR_OFFSET 0x2000 3441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 35b3b961448f702339444036f94252ff2ba7a99febManu Abraham/* shared registers and their order for context save/restore */ 36b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic int lcdc_shared_regs[] = { 37b3b961448f702339444036f94252ff2ba7a99febManu Abraham _LDDCKR, 38b3b961448f702339444036f94252ff2ba7a99febManu Abraham _LDDCKSTPR, 39b3b961448f702339444036f94252ff2ba7a99febManu Abraham _LDINTR, 40616f75e1979f5bd1f3241581c720349c2c31f6e7Manu Abraham _LDDDSR, 41b3b961448f702339444036f94252ff2ba7a99febManu Abraham _LDCNT1R, 4241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham _LDCNT2R, 43b3b961448f702339444036f94252ff2ba7a99febManu Abraham}; 4441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham#define NR_SHARED_REGS ARRAY_SIZE(lcdc_shared_regs) 45b3b961448f702339444036f94252ff2ba7a99febManu Abraham 46b3b961448f702339444036f94252ff2ba7a99febManu Abraham#define MAX_XRES 1920 47b3b961448f702339444036f94252ff2ba7a99febManu Abraham#define MAX_YRES 1080 48b3b961448f702339444036f94252ff2ba7a99febManu Abraham 49b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic unsigned long lcdc_offs_mainlcd[NR_CH_REGS] = { 50b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDDCKPAT1R] = 0x400, 51b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDDCKPAT2R] = 0x404, 52b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDMT1R] = 0x418, 53b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDMT2R] = 0x41c, 54b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDMT3R] = 0x420, 5541e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham [LDDFR] = 0x424, 56b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDSM1R] = 0x428, 57b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDSM2R] = 0x42c, 58b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDSA1R] = 0x430, 59b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDSA2R] = 0x434, 60b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDMLSR] = 0x438, 6141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham [LDHCNR] = 0x448, 62b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDHSYNR] = 0x44c, 63b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDVLNR] = 0x450, 64b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDVSYNR] = 0x454, 65b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDPMR] = 0x460, 6641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham [LDHAJR] = 0x4a0, 6741e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham}; 6841e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 69b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic unsigned long lcdc_offs_sublcd[NR_CH_REGS] = { 7041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham [LDDCKPAT1R] = 0x408, 71b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDDCKPAT2R] = 0x40c, 7241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham [LDMT1R] = 0x600, 73b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDMT2R] = 0x604, 74b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDMT3R] = 0x608, 75b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDDFR] = 0x60c, 76b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDSM1R] = 0x610, 77b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDSM2R] = 0x614, 78b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDSA1R] = 0x618, 79b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDMLSR] = 0x620, 80b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDHCNR] = 0x624, 81b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDHSYNR] = 0x628, 82b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDVLNR] = 0x62c, 83b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDVSYNR] = 0x630, 84b3b961448f702339444036f94252ff2ba7a99febManu Abraham [LDPMR] = 0x63c, 85b3b961448f702339444036f94252ff2ba7a99febManu Abraham}; 86b3b961448f702339444036f94252ff2ba7a99febManu Abraham 87b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic const struct fb_videomode default_720p = { 88b3b961448f702339444036f94252ff2ba7a99febManu Abraham .name = "HDMI 720p", 89b3b961448f702339444036f94252ff2ba7a99febManu Abraham .xres = 1280, 90b3b961448f702339444036f94252ff2ba7a99febManu Abraham .yres = 720, 91b3b961448f702339444036f94252ff2ba7a99febManu Abraham 92b3b961448f702339444036f94252ff2ba7a99febManu Abraham .left_margin = 220, 93b3b961448f702339444036f94252ff2ba7a99febManu Abraham .right_margin = 110, 94b3b961448f702339444036f94252ff2ba7a99febManu Abraham .hsync_len = 40, 95b3b961448f702339444036f94252ff2ba7a99febManu Abraham 96b3b961448f702339444036f94252ff2ba7a99febManu Abraham .upper_margin = 20, 97b3b961448f702339444036f94252ff2ba7a99febManu Abraham .lower_margin = 5, 98b3b961448f702339444036f94252ff2ba7a99febManu Abraham .vsync_len = 5, 9941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 10041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham .pixclock = 13468, 10141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham .refresh = 60, 10241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham .sync = FB_SYNC_VERT_HIGH_ACT | FB_SYNC_HOR_HIGH_ACT, 10341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham}; 10441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 10541e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abrahamstruct sh_mobile_lcdc_priv { 10641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham void __iomem *base; 10741e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham int irq; 108b3b961448f702339444036f94252ff2ba7a99febManu Abraham atomic_t hw_usecnt; 10941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham struct device *dev; 110b3b961448f702339444036f94252ff2ba7a99febManu Abraham struct clk *dot_clk; 11141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham unsigned long lddckr; 11241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham struct sh_mobile_lcdc_chan ch[2]; 113b3b961448f702339444036f94252ff2ba7a99febManu Abraham struct notifier_block notifier; 11441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham unsigned long saved_shared_regs[NR_SHARED_REGS]; 115b3b961448f702339444036f94252ff2ba7a99febManu Abraham int started; 11641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham int forced_bpp; /* 2 channel LCDC must share bpp setting */ 11741e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham struct sh_mobile_meram_info *meram_dev; 118b3b961448f702339444036f94252ff2ba7a99febManu Abraham}; 11941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 12041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abrahamstatic bool banked(int reg_nr) 12141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham{ 12241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham switch (reg_nr) { 12341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham case LDMT1R: 12441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham case LDMT2R: 12541e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham case LDMT3R: 12641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham case LDDFR: 12741e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham case LDSM1R: 12841e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham case LDSA1R: 12941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham case LDSA2R: 130b3b961448f702339444036f94252ff2ba7a99febManu Abraham case LDMLSR: 13141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham case LDHCNR: 132b3b961448f702339444036f94252ff2ba7a99febManu Abraham case LDHSYNR: 13341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham case LDVLNR: 13441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham case LDVSYNR: 135b3b961448f702339444036f94252ff2ba7a99febManu Abraham return true; 13641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham } 13741e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham return false; 138b3b961448f702339444036f94252ff2ba7a99febManu Abraham} 13941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 14041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abrahamstatic void lcdc_write_chan(struct sh_mobile_lcdc_chan *chan, 141b3b961448f702339444036f94252ff2ba7a99febManu Abraham int reg_nr, unsigned long data) 14241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham{ 14341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham iowrite32(data, chan->lcdc->base + chan->reg_offs[reg_nr]); 14441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham if (banked(reg_nr)) 14541e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham iowrite32(data, chan->lcdc->base + chan->reg_offs[reg_nr] + 14641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham SIDE_B_OFFSET); 147b3b961448f702339444036f94252ff2ba7a99febManu Abraham} 148b3b961448f702339444036f94252ff2ba7a99febManu Abraham 149b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic void lcdc_write_chan_mirror(struct sh_mobile_lcdc_chan *chan, 150b3b961448f702339444036f94252ff2ba7a99febManu Abraham int reg_nr, unsigned long data) 151b3b961448f702339444036f94252ff2ba7a99febManu Abraham{ 152b3b961448f702339444036f94252ff2ba7a99febManu Abraham iowrite32(data, chan->lcdc->base + chan->reg_offs[reg_nr] + 153b3b961448f702339444036f94252ff2ba7a99febManu Abraham MIRROR_OFFSET); 154b3b961448f702339444036f94252ff2ba7a99febManu Abraham} 155b3b961448f702339444036f94252ff2ba7a99febManu Abraham 156b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic unsigned long lcdc_read_chan(struct sh_mobile_lcdc_chan *chan, 15741e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham int reg_nr) 158b3b961448f702339444036f94252ff2ba7a99febManu Abraham{ 15941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham return ioread32(chan->lcdc->base + chan->reg_offs[reg_nr]); 160b3b961448f702339444036f94252ff2ba7a99febManu Abraham} 16141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 16241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abrahamstatic void lcdc_write(struct sh_mobile_lcdc_priv *priv, 163b3b961448f702339444036f94252ff2ba7a99febManu Abraham unsigned long reg_offs, unsigned long data) 164b3b961448f702339444036f94252ff2ba7a99febManu Abraham{ 165b3b961448f702339444036f94252ff2ba7a99febManu Abraham iowrite32(data, priv->base + reg_offs); 16641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham} 16741e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 16841e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abrahamstatic unsigned long lcdc_read(struct sh_mobile_lcdc_priv *priv, 169b3b961448f702339444036f94252ff2ba7a99febManu Abraham unsigned long reg_offs) 170b3b961448f702339444036f94252ff2ba7a99febManu Abraham{ 171b3b961448f702339444036f94252ff2ba7a99febManu Abraham return ioread32(priv->base + reg_offs); 172b3b961448f702339444036f94252ff2ba7a99febManu Abraham} 173b3b961448f702339444036f94252ff2ba7a99febManu Abraham 174b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic void lcdc_wait_bit(struct sh_mobile_lcdc_priv *priv, 175b3b961448f702339444036f94252ff2ba7a99febManu Abraham unsigned long reg_offs, 176b3b961448f702339444036f94252ff2ba7a99febManu Abraham unsigned long mask, unsigned long until) 177b3b961448f702339444036f94252ff2ba7a99febManu Abraham{ 178b3b961448f702339444036f94252ff2ba7a99febManu Abraham while ((lcdc_read(priv, reg_offs) & mask) != until) 179b3b961448f702339444036f94252ff2ba7a99febManu Abraham cpu_relax(); 18041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham} 18141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 18241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abrahamstatic int lcdc_chan_is_sublcd(struct sh_mobile_lcdc_chan *chan) 183b3b961448f702339444036f94252ff2ba7a99febManu Abraham{ 184b3b961448f702339444036f94252ff2ba7a99febManu Abraham return chan->cfg.chan == LCDC_CHAN_SUBLCD; 185b3b961448f702339444036f94252ff2ba7a99febManu Abraham} 186b3b961448f702339444036f94252ff2ba7a99febManu Abraham 187b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic void lcdc_sys_write_index(void *handle, unsigned long data) 188b3b961448f702339444036f94252ff2ba7a99febManu Abraham{ 189b3b961448f702339444036f94252ff2ba7a99febManu Abraham struct sh_mobile_lcdc_chan *ch = handle; 190b3b961448f702339444036f94252ff2ba7a99febManu Abraham 191b3b961448f702339444036f94252ff2ba7a99febManu Abraham lcdc_write(ch->lcdc, _LDDWD0R, data | LDDWDxR_WDACT); 192b3b961448f702339444036f94252ff2ba7a99febManu Abraham lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0); 19341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham lcdc_write(ch->lcdc, _LDDWAR, LDDWAR_WA | 19441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham (lcdc_chan_is_sublcd(ch) ? 2 : 0)); 19541e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0); 196b3b961448f702339444036f94252ff2ba7a99febManu Abraham} 197b3b961448f702339444036f94252ff2ba7a99febManu Abraham 198b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic void lcdc_sys_write_data(void *handle, unsigned long data) 19941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham{ 200b3b961448f702339444036f94252ff2ba7a99febManu Abraham struct sh_mobile_lcdc_chan *ch = handle; 20141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 20241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham lcdc_write(ch->lcdc, _LDDWD0R, data | LDDWDxR_WDACT | LDDWDxR_RSW); 20341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0); 204b3b961448f702339444036f94252ff2ba7a99febManu Abraham lcdc_write(ch->lcdc, _LDDWAR, LDDWAR_WA | 205f5ae4f6f482191c531ea9e50ac91d9bd2ffca171Manu Abraham (lcdc_chan_is_sublcd(ch) ? 2 : 0)); 206b3b961448f702339444036f94252ff2ba7a99febManu Abraham lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0); 207f5ae4f6f482191c531ea9e50ac91d9bd2ffca171Manu Abraham} 20841e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 20941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abrahamstatic unsigned long lcdc_sys_read_data(void *handle) 21041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham{ 211b3b961448f702339444036f94252ff2ba7a99febManu Abraham struct sh_mobile_lcdc_chan *ch = handle; 212b3b961448f702339444036f94252ff2ba7a99febManu Abraham 213b3b961448f702339444036f94252ff2ba7a99febManu Abraham lcdc_write(ch->lcdc, _LDDRDR, LDDRDR_RSR); 21441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0); 21541e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham lcdc_write(ch->lcdc, _LDDRAR, LDDRAR_RA | 216b3b961448f702339444036f94252ff2ba7a99febManu Abraham (lcdc_chan_is_sublcd(ch) ? 2 : 0)); 21741e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham udelay(1); 21841e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0); 219b3b961448f702339444036f94252ff2ba7a99febManu Abraham 220b3b961448f702339444036f94252ff2ba7a99febManu Abraham return lcdc_read(ch->lcdc, _LDDRDR) & LDDRDR_DRD_MASK; 221b3b961448f702339444036f94252ff2ba7a99febManu Abraham} 222b3b961448f702339444036f94252ff2ba7a99febManu Abraham 223b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstruct sh_mobile_lcdc_sys_bus_ops sh_mobile_lcdc_sys_bus_ops = { 224b3b961448f702339444036f94252ff2ba7a99febManu Abraham lcdc_sys_write_index, 225b3b961448f702339444036f94252ff2ba7a99febManu Abraham lcdc_sys_write_data, 226b3b961448f702339444036f94252ff2ba7a99febManu Abraham lcdc_sys_read_data, 227b3b961448f702339444036f94252ff2ba7a99febManu Abraham}; 228b3b961448f702339444036f94252ff2ba7a99febManu Abraham 229b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic void sh_mobile_lcdc_clk_on(struct sh_mobile_lcdc_priv *priv) 230b3b961448f702339444036f94252ff2ba7a99febManu Abraham{ 231b3b961448f702339444036f94252ff2ba7a99febManu Abraham if (atomic_inc_and_test(&priv->hw_usecnt)) { 232b3b961448f702339444036f94252ff2ba7a99febManu Abraham if (priv->dot_clk) 233b3b961448f702339444036f94252ff2ba7a99febManu Abraham clk_enable(priv->dot_clk); 234b3b961448f702339444036f94252ff2ba7a99febManu Abraham pm_runtime_get_sync(priv->dev); 235b3b961448f702339444036f94252ff2ba7a99febManu Abraham if (priv->meram_dev && priv->meram_dev->pdev) 236b3b961448f702339444036f94252ff2ba7a99febManu Abraham pm_runtime_get_sync(&priv->meram_dev->pdev->dev); 237b3b961448f702339444036f94252ff2ba7a99febManu Abraham } 238b3b961448f702339444036f94252ff2ba7a99febManu Abraham} 239b3b961448f702339444036f94252ff2ba7a99febManu Abraham 240b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic void sh_mobile_lcdc_clk_off(struct sh_mobile_lcdc_priv *priv) 241d9dd5f7168d6a61491996fc02e4deb9d96308178Manu Abraham{ 24241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham if (atomic_sub_return(1, &priv->hw_usecnt) == -1) { 24341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham if (priv->meram_dev && priv->meram_dev->pdev) 244b3b961448f702339444036f94252ff2ba7a99febManu Abraham pm_runtime_put_sync(&priv->meram_dev->pdev->dev); 245b3b961448f702339444036f94252ff2ba7a99febManu Abraham pm_runtime_put(priv->dev); 246b3b961448f702339444036f94252ff2ba7a99febManu Abraham if (priv->dot_clk) 247b3b961448f702339444036f94252ff2ba7a99febManu Abraham clk_disable(priv->dot_clk); 24868fe255cd15cf1fe04877fbbb0eafe80c43eff5dManu Abraham } 24968fe255cd15cf1fe04877fbbb0eafe80c43eff5dManu Abraham} 25041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 25141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abrahamstatic int sh_mobile_lcdc_sginit(struct fb_info *info, 2523e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham struct list_head *pagelist) 25341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham{ 25441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham struct sh_mobile_lcdc_chan *ch = info->par; 2553e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham unsigned int nr_pages_max = info->fix.smem_len >> PAGE_SHIFT; 25641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham struct page *page; 25741e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham int nr_pages = 0; 2583e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham 25941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham sg_init_table(ch->sglist, nr_pages_max); 26041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 2613e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham list_for_each_entry(page, pagelist, lru) 26241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham sg_set_page(&ch->sglist[nr_pages++], page, PAGE_SIZE, 0); 26341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 26441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham return nr_pages; 26541e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham} 26641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 267b3b961448f702339444036f94252ff2ba7a99febManu Abrahamstatic void sh_mobile_lcdc_deferred_io(struct fb_info *info, 26841e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham struct list_head *pagelist) 269b3b961448f702339444036f94252ff2ba7a99febManu Abraham{ 27041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham struct sh_mobile_lcdc_chan *ch = info->par; 271b3b961448f702339444036f94252ff2ba7a99febManu Abraham struct sh_mobile_lcdc_board_cfg *bcfg = &ch->cfg.board_cfg; 27241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 2733e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham /* enable clocks before accessing hardware */ 274f5ae4f6f482191c531ea9e50ac91d9bd2ffca171Manu Abraham sh_mobile_lcdc_clk_on(ch->lcdc); 2753e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham 2763e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham /* 2773e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham * It's possible to get here without anything on the pagelist via 2783e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham * sh_mobile_lcdc_deferred_io_touch() or via a userspace fsync() 279c5e598a6f89ca7335db9f327e24e3abd13d137cfManu Abraham * invocation. In the former case, the acceleration routines are 2803e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham * stepped in to when using the framebuffer console causing the 28141e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * workqueue to be scheduled without any dirty pages on the list. 28241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * 28341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * Despite this, a panel update is still needed given that the 2843e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham * acceleration routines have their own methods for writing in 28541e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * that still need to be updated. 28641e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * 2873e978a8284080d801d20cda377d9cf7c12fe68b9Manu Abraham * The fsync() and empty pagelist case could be optimized for, 28841e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * but we don't bother, as any application exhibiting such 28941e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham * behaviour is fundamentally broken anyways. 29041e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham */ 291b3b961448f702339444036f94252ff2ba7a99febManu Abraham if (!list_empty(pagelist)) { 29241e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham unsigned int nr_pages = sh_mobile_lcdc_sginit(info, pagelist); 29341e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham 29441e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham /* trigger panel update */ 29541e840b13e111ba18b138d055ddd250bd5ad5e39Manu Abraham dma_map_sg(info->dev, ch->sglist, nr_pages, DMA_TO_DEVICE); 296b3b961448f702339444036f94252ff2ba7a99febManu Abraham if (bcfg->start_transfer) 297 bcfg->start_transfer(bcfg->board_data, ch, 298 &sh_mobile_lcdc_sys_bus_ops); 299 lcdc_write_chan(ch, LDSM2R, LDSM2R_OSTRG); 300 dma_unmap_sg(info->dev, ch->sglist, nr_pages, DMA_TO_DEVICE); 301 } else { 302 if (bcfg->start_transfer) 303 bcfg->start_transfer(bcfg->board_data, ch, 304 &sh_mobile_lcdc_sys_bus_ops); 305 lcdc_write_chan(ch, LDSM2R, LDSM2R_OSTRG); 306 } 307} 308 309static void sh_mobile_lcdc_deferred_io_touch(struct fb_info *info) 310{ 311 struct fb_deferred_io *fbdefio = info->fbdefio; 312 313 if (fbdefio) 314 schedule_delayed_work(&info->deferred_work, fbdefio->delay); 315} 316 317static irqreturn_t sh_mobile_lcdc_irq(int irq, void *data) 318{ 319 struct sh_mobile_lcdc_priv *priv = data; 320 struct sh_mobile_lcdc_chan *ch; 321 unsigned long tmp; 322 unsigned long ldintr; 323 int is_sub; 324 int k; 325 326 /* acknowledge interrupt */ 327 ldintr = tmp = lcdc_read(priv, _LDINTR); 328 /* 329 * disable further VSYNC End IRQs, preserve all other enabled IRQs, 330 * write 0 to bits 0-6 to ack all triggered IRQs. 331 */ 332 tmp &= ~LDINTR_STATUS_MASK & ~LDINTR_VEE; 333 lcdc_write(priv, _LDINTR, tmp); 334 335 /* figure out if this interrupt is for main or sub lcd */ 336 is_sub = (lcdc_read(priv, _LDSR) & LDSR_MSS) ? 1 : 0; 337 338 /* wake up channel and disable clocks */ 339 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) { 340 ch = &priv->ch[k]; 341 342 if (!ch->enabled) 343 continue; 344 345 /* Frame Start */ 346 if (ldintr & LDINTR_FS) { 347 if (is_sub == lcdc_chan_is_sublcd(ch)) { 348 ch->frame_end = 1; 349 wake_up(&ch->frame_end_wait); 350 351 sh_mobile_lcdc_clk_off(priv); 352 } 353 } 354 355 /* VSYNC End */ 356 if (ldintr & LDINTR_VES) 357 complete(&ch->vsync_completion); 358 } 359 360 return IRQ_HANDLED; 361} 362 363static void sh_mobile_lcdc_start_stop(struct sh_mobile_lcdc_priv *priv, 364 int start) 365{ 366 unsigned long tmp = lcdc_read(priv, _LDCNT2R); 367 int k; 368 369 /* start or stop the lcdc */ 370 if (start) 371 lcdc_write(priv, _LDCNT2R, tmp | LDCNT2R_DO); 372 else 373 lcdc_write(priv, _LDCNT2R, tmp & ~LDCNT2R_DO); 374 375 /* wait until power is applied/stopped on all channels */ 376 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) 377 if (lcdc_read(priv, _LDCNT2R) & priv->ch[k].enabled) 378 while (1) { 379 tmp = lcdc_read_chan(&priv->ch[k], LDPMR) 380 & LDPMR_LPS; 381 if (start && tmp == LDPMR_LPS) 382 break; 383 if (!start && tmp == 0) 384 break; 385 cpu_relax(); 386 } 387 388 if (!start) 389 lcdc_write(priv, _LDDCKSTPR, 1); /* stop dotclock */ 390} 391 392static void sh_mobile_lcdc_geometry(struct sh_mobile_lcdc_chan *ch) 393{ 394 struct fb_var_screeninfo *var = &ch->info->var, *display_var = &ch->display_var; 395 unsigned long h_total, hsync_pos, display_h_total; 396 u32 tmp; 397 398 tmp = ch->ldmt1r_value; 399 tmp |= (var->sync & FB_SYNC_VERT_HIGH_ACT) ? 0 : LDMT1R_VPOL; 400 tmp |= (var->sync & FB_SYNC_HOR_HIGH_ACT) ? 0 : LDMT1R_HPOL; 401 tmp |= (ch->cfg.flags & LCDC_FLAGS_DWPOL) ? LDMT1R_DWPOL : 0; 402 tmp |= (ch->cfg.flags & LCDC_FLAGS_DIPOL) ? LDMT1R_DIPOL : 0; 403 tmp |= (ch->cfg.flags & LCDC_FLAGS_DAPOL) ? LDMT1R_DAPOL : 0; 404 tmp |= (ch->cfg.flags & LCDC_FLAGS_HSCNT) ? LDMT1R_HSCNT : 0; 405 tmp |= (ch->cfg.flags & LCDC_FLAGS_DWCNT) ? LDMT1R_DWCNT : 0; 406 lcdc_write_chan(ch, LDMT1R, tmp); 407 408 /* setup SYS bus */ 409 lcdc_write_chan(ch, LDMT2R, ch->cfg.sys_bus_cfg.ldmt2r); 410 lcdc_write_chan(ch, LDMT3R, ch->cfg.sys_bus_cfg.ldmt3r); 411 412 /* horizontal configuration */ 413 h_total = display_var->xres + display_var->hsync_len + 414 display_var->left_margin + display_var->right_margin; 415 tmp = h_total / 8; /* HTCN */ 416 tmp |= (min(display_var->xres, var->xres) / 8) << 16; /* HDCN */ 417 lcdc_write_chan(ch, LDHCNR, tmp); 418 419 hsync_pos = display_var->xres + display_var->right_margin; 420 tmp = hsync_pos / 8; /* HSYNP */ 421 tmp |= (display_var->hsync_len / 8) << 16; /* HSYNW */ 422 lcdc_write_chan(ch, LDHSYNR, tmp); 423 424 /* vertical configuration */ 425 tmp = display_var->yres + display_var->vsync_len + 426 display_var->upper_margin + display_var->lower_margin; /* VTLN */ 427 tmp |= min(display_var->yres, var->yres) << 16; /* VDLN */ 428 lcdc_write_chan(ch, LDVLNR, tmp); 429 430 tmp = display_var->yres + display_var->lower_margin; /* VSYNP */ 431 tmp |= display_var->vsync_len << 16; /* VSYNW */ 432 lcdc_write_chan(ch, LDVSYNR, tmp); 433 434 /* Adjust horizontal synchronisation for HDMI */ 435 display_h_total = display_var->xres + display_var->hsync_len + 436 display_var->left_margin + display_var->right_margin; 437 tmp = ((display_var->xres & 7) << 24) | 438 ((display_h_total & 7) << 16) | 439 ((display_var->hsync_len & 7) << 8) | 440 hsync_pos; 441 lcdc_write_chan(ch, LDHAJR, tmp); 442} 443 444static int sh_mobile_lcdc_start(struct sh_mobile_lcdc_priv *priv) 445{ 446 struct sh_mobile_lcdc_chan *ch; 447 struct sh_mobile_lcdc_board_cfg *board_cfg; 448 unsigned long tmp; 449 int bpp = 0; 450 unsigned long ldddsr; 451 int k, m, ret; 452 453 /* enable clocks before accessing the hardware */ 454 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) { 455 if (priv->ch[k].enabled) { 456 sh_mobile_lcdc_clk_on(priv); 457 if (!bpp) 458 bpp = priv->ch[k].info->var.bits_per_pixel; 459 } 460 } 461 462 /* reset */ 463 lcdc_write(priv, _LDCNT2R, lcdc_read(priv, _LDCNT2R) | LDCNT2R_BR); 464 lcdc_wait_bit(priv, _LDCNT2R, LDCNT2R_BR, 0); 465 466 /* enable LCDC channels */ 467 tmp = lcdc_read(priv, _LDCNT2R); 468 tmp |= priv->ch[0].enabled; 469 tmp |= priv->ch[1].enabled; 470 lcdc_write(priv, _LDCNT2R, tmp); 471 472 /* read data from external memory, avoid using the BEU for now */ 473 lcdc_write(priv, _LDCNT2R, lcdc_read(priv, _LDCNT2R) & ~LDCNT2R_MD); 474 475 /* stop the lcdc first */ 476 sh_mobile_lcdc_start_stop(priv, 0); 477 478 /* configure clocks */ 479 tmp = priv->lddckr; 480 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) { 481 ch = &priv->ch[k]; 482 483 if (!priv->ch[k].enabled) 484 continue; 485 486 m = ch->cfg.clock_divider; 487 if (!m) 488 continue; 489 490 if (m == 1) 491 m = LDDCKR_MOSEL; 492 tmp |= m << (lcdc_chan_is_sublcd(ch) ? 8 : 0); 493 494 /* FIXME: sh7724 can only use 42, 48, 54 and 60 for the divider denominator */ 495 lcdc_write_chan(ch, LDDCKPAT1R, 0); 496 lcdc_write_chan(ch, LDDCKPAT2R, (1 << (m/2)) - 1); 497 } 498 499 lcdc_write(priv, _LDDCKR, tmp); 500 501 /* start dotclock again */ 502 lcdc_write(priv, _LDDCKSTPR, 0); 503 lcdc_wait_bit(priv, _LDDCKSTPR, ~0, 0); 504 505 /* interrupts are disabled to begin with */ 506 lcdc_write(priv, _LDINTR, 0); 507 508 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) { 509 ch = &priv->ch[k]; 510 511 if (!ch->enabled) 512 continue; 513 514 sh_mobile_lcdc_geometry(ch); 515 516 /* power supply */ 517 lcdc_write_chan(ch, LDPMR, 0); 518 519 board_cfg = &ch->cfg.board_cfg; 520 if (board_cfg->setup_sys) { 521 ret = board_cfg->setup_sys(board_cfg->board_data, 522 ch, &sh_mobile_lcdc_sys_bus_ops); 523 if (ret) 524 return ret; 525 } 526 } 527 528 /* word and long word swap */ 529 ldddsr = lcdc_read(priv, _LDDDSR); 530 if (priv->ch[0].info->var.nonstd) 531 ldddsr |= LDDDSR_LS | LDDDSR_WS | LDDDSR_BS; 532 else { 533 switch (bpp) { 534 case 16: 535 ldddsr |= LDDDSR_LS | LDDDSR_WS; 536 break; 537 case 24: 538 ldddsr |= LDDDSR_LS | LDDDSR_WS | LDDDSR_BS; 539 break; 540 case 32: 541 ldddsr |= LDDDSR_LS; 542 break; 543 } 544 } 545 lcdc_write(priv, _LDDDSR, ldddsr); 546 547 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) { 548 unsigned long base_addr_y; 549 unsigned long base_addr_c = 0; 550 int pitch; 551 ch = &priv->ch[k]; 552 553 if (!priv->ch[k].enabled) 554 continue; 555 556 /* set bpp format in PKF[4:0] */ 557 tmp = lcdc_read_chan(ch, LDDFR); 558 tmp &= ~(LDDFR_CF0 | LDDFR_CC | LDDFR_YF_MASK | LDDFR_PKF_MASK); 559 if (ch->info->var.nonstd) { 560 tmp |= (ch->info->var.nonstd << 16); 561 switch (ch->info->var.bits_per_pixel) { 562 case 12: 563 break; 564 case 16: 565 tmp |= LDDFR_YF_422; 566 break; 567 case 24: 568 tmp |= LDDFR_YF_444; 569 break; 570 } 571 } else { 572 switch (ch->info->var.bits_per_pixel) { 573 case 16: 574 tmp |= LDDFR_PKF_RGB16; 575 break; 576 case 24: 577 tmp |= LDDFR_PKF_RGB24; 578 break; 579 case 32: 580 tmp |= LDDFR_PKF_ARGB32; 581 break; 582 } 583 } 584 lcdc_write_chan(ch, LDDFR, tmp); 585 586 base_addr_y = ch->info->fix.smem_start; 587 base_addr_c = base_addr_y + 588 ch->info->var.xres * 589 ch->info->var.yres_virtual; 590 pitch = ch->info->fix.line_length; 591 592 /* test if we can enable meram */ 593 if (ch->cfg.meram_cfg && priv->meram_dev && 594 priv->meram_dev->ops) { 595 struct sh_mobile_meram_cfg *cfg; 596 struct sh_mobile_meram_info *mdev; 597 unsigned long icb_addr_y, icb_addr_c; 598 int icb_pitch; 599 int pf; 600 601 cfg = ch->cfg.meram_cfg; 602 mdev = priv->meram_dev; 603 /* we need to de-init configured ICBs before we 604 * we can re-initialize them. 605 */ 606 if (ch->meram_enabled) 607 mdev->ops->meram_unregister(mdev, cfg); 608 609 ch->meram_enabled = 0; 610 611 if (ch->info->var.nonstd) { 612 if (ch->info->var.bits_per_pixel == 24) 613 pf = SH_MOBILE_MERAM_PF_NV24; 614 else 615 pf = SH_MOBILE_MERAM_PF_NV; 616 } else { 617 pf = SH_MOBILE_MERAM_PF_RGB; 618 } 619 620 ret = mdev->ops->meram_register(mdev, cfg, pitch, 621 ch->info->var.yres, 622 pf, 623 base_addr_y, 624 base_addr_c, 625 &icb_addr_y, 626 &icb_addr_c, 627 &icb_pitch); 628 if (!ret) { 629 /* set LDSA1R value */ 630 base_addr_y = icb_addr_y; 631 pitch = icb_pitch; 632 633 /* set LDSA2R value if required */ 634 if (base_addr_c) 635 base_addr_c = icb_addr_c; 636 637 ch->meram_enabled = 1; 638 } 639 } 640 641 /* point out our frame buffer */ 642 lcdc_write_chan(ch, LDSA1R, base_addr_y); 643 if (ch->info->var.nonstd) 644 lcdc_write_chan(ch, LDSA2R, base_addr_c); 645 646 /* set line size */ 647 lcdc_write_chan(ch, LDMLSR, pitch); 648 649 /* setup deferred io if SYS bus */ 650 tmp = ch->cfg.sys_bus_cfg.deferred_io_msec; 651 if (ch->ldmt1r_value & LDMT1R_IFM && tmp) { 652 ch->defio.deferred_io = sh_mobile_lcdc_deferred_io; 653 ch->defio.delay = msecs_to_jiffies(tmp); 654 ch->info->fbdefio = &ch->defio; 655 fb_deferred_io_init(ch->info); 656 657 /* one-shot mode */ 658 lcdc_write_chan(ch, LDSM1R, LDSM1R_OS); 659 660 /* enable "Frame End Interrupt Enable" bit */ 661 lcdc_write(priv, _LDINTR, LDINTR_FE); 662 663 } else { 664 /* continuous read mode */ 665 lcdc_write_chan(ch, LDSM1R, 0); 666 } 667 } 668 669 /* display output */ 670 lcdc_write(priv, _LDCNT1R, LDCNT1R_DE); 671 672 /* start the lcdc */ 673 sh_mobile_lcdc_start_stop(priv, 1); 674 priv->started = 1; 675 676 /* tell the board code to enable the panel */ 677 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) { 678 ch = &priv->ch[k]; 679 if (!ch->enabled) 680 continue; 681 682 board_cfg = &ch->cfg.board_cfg; 683 if (board_cfg->display_on && try_module_get(board_cfg->owner)) { 684 board_cfg->display_on(board_cfg->board_data, ch->info); 685 module_put(board_cfg->owner); 686 } 687 688 if (ch->bl) { 689 ch->bl->props.power = FB_BLANK_UNBLANK; 690 backlight_update_status(ch->bl); 691 } 692 } 693 694 return 0; 695} 696 697static void sh_mobile_lcdc_stop(struct sh_mobile_lcdc_priv *priv) 698{ 699 struct sh_mobile_lcdc_chan *ch; 700 struct sh_mobile_lcdc_board_cfg *board_cfg; 701 int k; 702 703 /* clean up deferred io and ask board code to disable panel */ 704 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) { 705 ch = &priv->ch[k]; 706 if (!ch->enabled) 707 continue; 708 709 /* deferred io mode: 710 * flush frame, and wait for frame end interrupt 711 * clean up deferred io and enable clock 712 */ 713 if (ch->info && ch->info->fbdefio) { 714 ch->frame_end = 0; 715 schedule_delayed_work(&ch->info->deferred_work, 0); 716 wait_event(ch->frame_end_wait, ch->frame_end); 717 fb_deferred_io_cleanup(ch->info); 718 ch->info->fbdefio = NULL; 719 sh_mobile_lcdc_clk_on(priv); 720 } 721 722 if (ch->bl) { 723 ch->bl->props.power = FB_BLANK_POWERDOWN; 724 backlight_update_status(ch->bl); 725 } 726 727 board_cfg = &ch->cfg.board_cfg; 728 if (board_cfg->display_off && try_module_get(board_cfg->owner)) { 729 board_cfg->display_off(board_cfg->board_data); 730 module_put(board_cfg->owner); 731 } 732 733 /* disable the meram */ 734 if (ch->meram_enabled) { 735 struct sh_mobile_meram_cfg *cfg; 736 struct sh_mobile_meram_info *mdev; 737 cfg = ch->cfg.meram_cfg; 738 mdev = priv->meram_dev; 739 mdev->ops->meram_unregister(mdev, cfg); 740 ch->meram_enabled = 0; 741 } 742 743 } 744 745 /* stop the lcdc */ 746 if (priv->started) { 747 sh_mobile_lcdc_start_stop(priv, 0); 748 priv->started = 0; 749 } 750 751 /* stop clocks */ 752 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) 753 if (priv->ch[k].enabled) 754 sh_mobile_lcdc_clk_off(priv); 755} 756 757static int sh_mobile_lcdc_check_interface(struct sh_mobile_lcdc_chan *ch) 758{ 759 int interface_type = ch->cfg.interface_type; 760 761 switch (interface_type) { 762 case RGB8: 763 case RGB9: 764 case RGB12A: 765 case RGB12B: 766 case RGB16: 767 case RGB18: 768 case RGB24: 769 case SYS8A: 770 case SYS8B: 771 case SYS8C: 772 case SYS8D: 773 case SYS9: 774 case SYS12: 775 case SYS16A: 776 case SYS16B: 777 case SYS16C: 778 case SYS18: 779 case SYS24: 780 break; 781 default: 782 return -EINVAL; 783 } 784 785 /* SUBLCD only supports SYS interface */ 786 if (lcdc_chan_is_sublcd(ch)) { 787 if (!(interface_type & LDMT1R_IFM)) 788 return -EINVAL; 789 790 interface_type &= ~LDMT1R_IFM; 791 } 792 793 ch->ldmt1r_value = interface_type; 794 return 0; 795} 796 797static int sh_mobile_lcdc_setup_clocks(struct platform_device *pdev, 798 int clock_source, 799 struct sh_mobile_lcdc_priv *priv) 800{ 801 char *str; 802 803 switch (clock_source) { 804 case LCDC_CLK_BUS: 805 str = "bus_clk"; 806 priv->lddckr = LDDCKR_ICKSEL_BUS; 807 break; 808 case LCDC_CLK_PERIPHERAL: 809 str = "peripheral_clk"; 810 priv->lddckr = LDDCKR_ICKSEL_MIPI; 811 break; 812 case LCDC_CLK_EXTERNAL: 813 str = NULL; 814 priv->lddckr = LDDCKR_ICKSEL_HDMI; 815 break; 816 default: 817 return -EINVAL; 818 } 819 820 if (str) { 821 priv->dot_clk = clk_get(&pdev->dev, str); 822 if (IS_ERR(priv->dot_clk)) { 823 dev_err(&pdev->dev, "cannot get dot clock %s\n", str); 824 return PTR_ERR(priv->dot_clk); 825 } 826 } 827 828 /* Runtime PM support involves two step for this driver: 829 * 1) Enable Runtime PM 830 * 2) Force Runtime PM Resume since hardware is accessed from probe() 831 */ 832 priv->dev = &pdev->dev; 833 pm_runtime_enable(priv->dev); 834 pm_runtime_resume(priv->dev); 835 return 0; 836} 837 838static int sh_mobile_lcdc_setcolreg(u_int regno, 839 u_int red, u_int green, u_int blue, 840 u_int transp, struct fb_info *info) 841{ 842 u32 *palette = info->pseudo_palette; 843 844 if (regno >= PALETTE_NR) 845 return -EINVAL; 846 847 /* only FB_VISUAL_TRUECOLOR supported */ 848 849 red >>= 16 - info->var.red.length; 850 green >>= 16 - info->var.green.length; 851 blue >>= 16 - info->var.blue.length; 852 transp >>= 16 - info->var.transp.length; 853 854 palette[regno] = (red << info->var.red.offset) | 855 (green << info->var.green.offset) | 856 (blue << info->var.blue.offset) | 857 (transp << info->var.transp.offset); 858 859 return 0; 860} 861 862static struct fb_fix_screeninfo sh_mobile_lcdc_fix = { 863 .id = "SH Mobile LCDC", 864 .type = FB_TYPE_PACKED_PIXELS, 865 .visual = FB_VISUAL_TRUECOLOR, 866 .accel = FB_ACCEL_NONE, 867 .xpanstep = 0, 868 .ypanstep = 1, 869 .ywrapstep = 0, 870}; 871 872static void sh_mobile_lcdc_fillrect(struct fb_info *info, 873 const struct fb_fillrect *rect) 874{ 875 sys_fillrect(info, rect); 876 sh_mobile_lcdc_deferred_io_touch(info); 877} 878 879static void sh_mobile_lcdc_copyarea(struct fb_info *info, 880 const struct fb_copyarea *area) 881{ 882 sys_copyarea(info, area); 883 sh_mobile_lcdc_deferred_io_touch(info); 884} 885 886static void sh_mobile_lcdc_imageblit(struct fb_info *info, 887 const struct fb_image *image) 888{ 889 sys_imageblit(info, image); 890 sh_mobile_lcdc_deferred_io_touch(info); 891} 892 893static int sh_mobile_fb_pan_display(struct fb_var_screeninfo *var, 894 struct fb_info *info) 895{ 896 struct sh_mobile_lcdc_chan *ch = info->par; 897 struct sh_mobile_lcdc_priv *priv = ch->lcdc; 898 unsigned long ldrcntr; 899 unsigned long new_pan_offset; 900 unsigned long base_addr_y, base_addr_c; 901 unsigned long c_offset; 902 903 if (!var->nonstd) 904 new_pan_offset = (var->yoffset * info->fix.line_length) + 905 (var->xoffset * (info->var.bits_per_pixel / 8)); 906 else 907 new_pan_offset = (var->yoffset * info->fix.line_length) + 908 (var->xoffset); 909 910 if (new_pan_offset == ch->pan_offset) 911 return 0; /* No change, do nothing */ 912 913 ldrcntr = lcdc_read(priv, _LDRCNTR); 914 915 /* Set the source address for the next refresh */ 916 base_addr_y = ch->dma_handle + new_pan_offset; 917 if (var->nonstd) { 918 /* Set y offset */ 919 c_offset = (var->yoffset * 920 info->fix.line_length * 921 (info->var.bits_per_pixel - 8)) / 8; 922 base_addr_c = ch->dma_handle + var->xres * var->yres_virtual + 923 c_offset; 924 /* Set x offset */ 925 if (info->var.bits_per_pixel == 24) 926 base_addr_c += 2 * var->xoffset; 927 else 928 base_addr_c += var->xoffset; 929 } else 930 base_addr_c = 0; 931 932 if (!ch->meram_enabled) { 933 lcdc_write_chan_mirror(ch, LDSA1R, base_addr_y); 934 if (base_addr_c) 935 lcdc_write_chan_mirror(ch, LDSA2R, base_addr_c); 936 } else { 937 struct sh_mobile_meram_cfg *cfg; 938 struct sh_mobile_meram_info *mdev; 939 unsigned long icb_addr_y, icb_addr_c; 940 int ret; 941 942 cfg = ch->cfg.meram_cfg; 943 mdev = priv->meram_dev; 944 ret = mdev->ops->meram_update(mdev, cfg, 945 base_addr_y, base_addr_c, 946 &icb_addr_y, &icb_addr_c); 947 if (ret) 948 return ret; 949 950 lcdc_write_chan_mirror(ch, LDSA1R, icb_addr_y); 951 if (icb_addr_c) 952 lcdc_write_chan_mirror(ch, LDSA2R, icb_addr_c); 953 954 } 955 956 if (lcdc_chan_is_sublcd(ch)) 957 lcdc_write(ch->lcdc, _LDRCNTR, ldrcntr ^ LDRCNTR_SRS); 958 else 959 lcdc_write(ch->lcdc, _LDRCNTR, ldrcntr ^ LDRCNTR_MRS); 960 961 ch->pan_offset = new_pan_offset; 962 963 sh_mobile_lcdc_deferred_io_touch(info); 964 965 return 0; 966} 967 968static int sh_mobile_wait_for_vsync(struct fb_info *info) 969{ 970 struct sh_mobile_lcdc_chan *ch = info->par; 971 unsigned long ldintr; 972 int ret; 973 974 /* Enable VSync End interrupt */ 975 ldintr = lcdc_read(ch->lcdc, _LDINTR); 976 ldintr |= LDINTR_VEE; 977 lcdc_write(ch->lcdc, _LDINTR, ldintr); 978 979 ret = wait_for_completion_interruptible_timeout(&ch->vsync_completion, 980 msecs_to_jiffies(100)); 981 if (!ret) 982 return -ETIMEDOUT; 983 984 return 0; 985} 986 987static int sh_mobile_ioctl(struct fb_info *info, unsigned int cmd, 988 unsigned long arg) 989{ 990 int retval; 991 992 switch (cmd) { 993 case FBIO_WAITFORVSYNC: 994 retval = sh_mobile_wait_for_vsync(info); 995 break; 996 997 default: 998 retval = -ENOIOCTLCMD; 999 break; 1000 } 1001 return retval; 1002} 1003 1004static void sh_mobile_fb_reconfig(struct fb_info *info) 1005{ 1006 struct sh_mobile_lcdc_chan *ch = info->par; 1007 struct fb_videomode mode1, mode2; 1008 struct fb_event event; 1009 int evnt = FB_EVENT_MODE_CHANGE_ALL; 1010 1011 if (ch->use_count > 1 || (ch->use_count == 1 && !info->fbcon_par)) 1012 /* More framebuffer users are active */ 1013 return; 1014 1015 fb_var_to_videomode(&mode1, &ch->display_var); 1016 fb_var_to_videomode(&mode2, &info->var); 1017 1018 if (fb_mode_is_equal(&mode1, &mode2)) 1019 return; 1020 1021 /* Display has been re-plugged, framebuffer is free now, reconfigure */ 1022 if (fb_set_var(info, &ch->display_var) < 0) 1023 /* Couldn't reconfigure, hopefully, can continue as before */ 1024 return; 1025 1026 if (info->var.nonstd) 1027 info->fix.line_length = mode1.xres; 1028 else 1029 info->fix.line_length = mode1.xres * (ch->cfg.bpp / 8); 1030 1031 /* 1032 * fb_set_var() calls the notifier change internally, only if 1033 * FBINFO_MISC_USEREVENT flag is set. Since we do not want to fake a 1034 * user event, we have to call the chain ourselves. 1035 */ 1036 event.info = info; 1037 event.data = &mode1; 1038 fb_notifier_call_chain(evnt, &event); 1039} 1040 1041/* 1042 * Locking: both .fb_release() and .fb_open() are called with info->lock held if 1043 * user == 1, or with console sem held, if user == 0. 1044 */ 1045static int sh_mobile_release(struct fb_info *info, int user) 1046{ 1047 struct sh_mobile_lcdc_chan *ch = info->par; 1048 1049 mutex_lock(&ch->open_lock); 1050 dev_dbg(info->dev, "%s(): %d users\n", __func__, ch->use_count); 1051 1052 ch->use_count--; 1053 1054 /* Nothing to reconfigure, when called from fbcon */ 1055 if (user) { 1056 console_lock(); 1057 sh_mobile_fb_reconfig(info); 1058 console_unlock(); 1059 } 1060 1061 mutex_unlock(&ch->open_lock); 1062 1063 return 0; 1064} 1065 1066static int sh_mobile_open(struct fb_info *info, int user) 1067{ 1068 struct sh_mobile_lcdc_chan *ch = info->par; 1069 1070 mutex_lock(&ch->open_lock); 1071 ch->use_count++; 1072 1073 dev_dbg(info->dev, "%s(): %d users\n", __func__, ch->use_count); 1074 mutex_unlock(&ch->open_lock); 1075 1076 return 0; 1077} 1078 1079static int sh_mobile_check_var(struct fb_var_screeninfo *var, struct fb_info *info) 1080{ 1081 struct sh_mobile_lcdc_chan *ch = info->par; 1082 struct sh_mobile_lcdc_priv *p = ch->lcdc; 1083 1084 if (var->xres > MAX_XRES || var->yres > MAX_YRES || 1085 var->xres * var->yres * (ch->cfg.bpp / 8) * 2 > info->fix.smem_len) { 1086 dev_warn(info->dev, "Invalid info: %u-%u-%u-%u x %u-%u-%u-%u @ %lukHz!\n", 1087 var->left_margin, var->xres, var->right_margin, var->hsync_len, 1088 var->upper_margin, var->yres, var->lower_margin, var->vsync_len, 1089 PICOS2KHZ(var->pixclock)); 1090 return -EINVAL; 1091 } 1092 1093 /* only accept the forced_bpp for dual channel configurations */ 1094 if (p->forced_bpp && p->forced_bpp != var->bits_per_pixel) 1095 return -EINVAL; 1096 1097 switch (var->bits_per_pixel) { 1098 case 16: /* PKF[4:0] = 00011 - RGB 565 */ 1099 case 24: /* PKF[4:0] = 01011 - RGB 888 */ 1100 case 32: /* PKF[4:0] = 00000 - RGBA 888 */ 1101 break; 1102 default: 1103 return -EINVAL; 1104 } 1105 1106 return 0; 1107} 1108 1109/* 1110 * Screen blanking. Behavior is as follows: 1111 * FB_BLANK_UNBLANK: screen unblanked, clocks enabled 1112 * FB_BLANK_NORMAL: screen blanked, clocks enabled 1113 * FB_BLANK_VSYNC, 1114 * FB_BLANK_HSYNC, 1115 * FB_BLANK_POWEROFF: screen blanked, clocks disabled 1116 */ 1117static int sh_mobile_lcdc_blank(int blank, struct fb_info *info) 1118{ 1119 struct sh_mobile_lcdc_chan *ch = info->par; 1120 struct sh_mobile_lcdc_priv *p = ch->lcdc; 1121 1122 /* blank the screen? */ 1123 if (blank > FB_BLANK_UNBLANK && ch->blank_status == FB_BLANK_UNBLANK) { 1124 struct fb_fillrect rect = { 1125 .width = info->var.xres, 1126 .height = info->var.yres, 1127 }; 1128 sh_mobile_lcdc_fillrect(info, &rect); 1129 } 1130 /* turn clocks on? */ 1131 if (blank <= FB_BLANK_NORMAL && ch->blank_status > FB_BLANK_NORMAL) { 1132 sh_mobile_lcdc_clk_on(p); 1133 } 1134 /* turn clocks off? */ 1135 if (blank > FB_BLANK_NORMAL && ch->blank_status <= FB_BLANK_NORMAL) { 1136 /* make sure the screen is updated with the black fill before 1137 * switching the clocks off. one vsync is not enough since 1138 * blanking may occur in the middle of a refresh. deferred io 1139 * mode will reenable the clocks and update the screen in time, 1140 * so it does not need this. */ 1141 if (!info->fbdefio) { 1142 sh_mobile_wait_for_vsync(info); 1143 sh_mobile_wait_for_vsync(info); 1144 } 1145 sh_mobile_lcdc_clk_off(p); 1146 } 1147 1148 ch->blank_status = blank; 1149 return 0; 1150} 1151 1152static struct fb_ops sh_mobile_lcdc_ops = { 1153 .owner = THIS_MODULE, 1154 .fb_setcolreg = sh_mobile_lcdc_setcolreg, 1155 .fb_read = fb_sys_read, 1156 .fb_write = fb_sys_write, 1157 .fb_fillrect = sh_mobile_lcdc_fillrect, 1158 .fb_copyarea = sh_mobile_lcdc_copyarea, 1159 .fb_imageblit = sh_mobile_lcdc_imageblit, 1160 .fb_blank = sh_mobile_lcdc_blank, 1161 .fb_pan_display = sh_mobile_fb_pan_display, 1162 .fb_ioctl = sh_mobile_ioctl, 1163 .fb_open = sh_mobile_open, 1164 .fb_release = sh_mobile_release, 1165 .fb_check_var = sh_mobile_check_var, 1166}; 1167 1168static int sh_mobile_lcdc_update_bl(struct backlight_device *bdev) 1169{ 1170 struct sh_mobile_lcdc_chan *ch = bl_get_data(bdev); 1171 struct sh_mobile_lcdc_board_cfg *cfg = &ch->cfg.board_cfg; 1172 int brightness = bdev->props.brightness; 1173 1174 if (bdev->props.power != FB_BLANK_UNBLANK || 1175 bdev->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK)) 1176 brightness = 0; 1177 1178 return cfg->set_brightness(cfg->board_data, brightness); 1179} 1180 1181static int sh_mobile_lcdc_get_brightness(struct backlight_device *bdev) 1182{ 1183 struct sh_mobile_lcdc_chan *ch = bl_get_data(bdev); 1184 struct sh_mobile_lcdc_board_cfg *cfg = &ch->cfg.board_cfg; 1185 1186 return cfg->get_brightness(cfg->board_data); 1187} 1188 1189static int sh_mobile_lcdc_check_fb(struct backlight_device *bdev, 1190 struct fb_info *info) 1191{ 1192 return (info->bl_dev == bdev); 1193} 1194 1195static struct backlight_ops sh_mobile_lcdc_bl_ops = { 1196 .options = BL_CORE_SUSPENDRESUME, 1197 .update_status = sh_mobile_lcdc_update_bl, 1198 .get_brightness = sh_mobile_lcdc_get_brightness, 1199 .check_fb = sh_mobile_lcdc_check_fb, 1200}; 1201 1202static struct backlight_device *sh_mobile_lcdc_bl_probe(struct device *parent, 1203 struct sh_mobile_lcdc_chan *ch) 1204{ 1205 struct backlight_device *bl; 1206 1207 bl = backlight_device_register(ch->cfg.bl_info.name, parent, ch, 1208 &sh_mobile_lcdc_bl_ops, NULL); 1209 if (IS_ERR(bl)) { 1210 dev_err(parent, "unable to register backlight device: %ld\n", 1211 PTR_ERR(bl)); 1212 return NULL; 1213 } 1214 1215 bl->props.max_brightness = ch->cfg.bl_info.max_brightness; 1216 bl->props.brightness = bl->props.max_brightness; 1217 backlight_update_status(bl); 1218 1219 return bl; 1220} 1221 1222static void sh_mobile_lcdc_bl_remove(struct backlight_device *bdev) 1223{ 1224 backlight_device_unregister(bdev); 1225} 1226 1227static int sh_mobile_lcdc_set_bpp(struct fb_var_screeninfo *var, int bpp, 1228 int nonstd) 1229{ 1230 if (nonstd) { 1231 switch (bpp) { 1232 case 12: 1233 case 16: 1234 case 24: 1235 var->bits_per_pixel = bpp; 1236 var->nonstd = nonstd; 1237 return 0; 1238 default: 1239 return -EINVAL; 1240 } 1241 } 1242 1243 switch (bpp) { 1244 case 16: /* PKF[4:0] = 00011 - RGB 565 */ 1245 var->red.offset = 11; 1246 var->red.length = 5; 1247 var->green.offset = 5; 1248 var->green.length = 6; 1249 var->blue.offset = 0; 1250 var->blue.length = 5; 1251 var->transp.offset = 0; 1252 var->transp.length = 0; 1253 break; 1254 1255 case 24: /* PKF[4:0] = 01011 - RGB 888 */ 1256 var->red.offset = 16; 1257 var->red.length = 8; 1258 var->green.offset = 8; 1259 var->green.length = 8; 1260 var->blue.offset = 0; 1261 var->blue.length = 8; 1262 var->transp.offset = 0; 1263 var->transp.length = 0; 1264 break; 1265 1266 case 32: /* PKF[4:0] = 00000 - RGBA 888 */ 1267 var->red.offset = 16; 1268 var->red.length = 8; 1269 var->green.offset = 8; 1270 var->green.length = 8; 1271 var->blue.offset = 0; 1272 var->blue.length = 8; 1273 var->transp.offset = 24; 1274 var->transp.length = 8; 1275 break; 1276 default: 1277 return -EINVAL; 1278 } 1279 var->bits_per_pixel = bpp; 1280 var->red.msb_right = 0; 1281 var->green.msb_right = 0; 1282 var->blue.msb_right = 0; 1283 var->transp.msb_right = 0; 1284 return 0; 1285} 1286 1287static int sh_mobile_lcdc_suspend(struct device *dev) 1288{ 1289 struct platform_device *pdev = to_platform_device(dev); 1290 1291 sh_mobile_lcdc_stop(platform_get_drvdata(pdev)); 1292 return 0; 1293} 1294 1295static int sh_mobile_lcdc_resume(struct device *dev) 1296{ 1297 struct platform_device *pdev = to_platform_device(dev); 1298 1299 return sh_mobile_lcdc_start(platform_get_drvdata(pdev)); 1300} 1301 1302static int sh_mobile_lcdc_runtime_suspend(struct device *dev) 1303{ 1304 struct platform_device *pdev = to_platform_device(dev); 1305 struct sh_mobile_lcdc_priv *p = platform_get_drvdata(pdev); 1306 struct sh_mobile_lcdc_chan *ch; 1307 int k, n; 1308 1309 /* save per-channel registers */ 1310 for (k = 0; k < ARRAY_SIZE(p->ch); k++) { 1311 ch = &p->ch[k]; 1312 if (!ch->enabled) 1313 continue; 1314 for (n = 0; n < NR_CH_REGS; n++) 1315 ch->saved_ch_regs[n] = lcdc_read_chan(ch, n); 1316 } 1317 1318 /* save shared registers */ 1319 for (n = 0; n < NR_SHARED_REGS; n++) 1320 p->saved_shared_regs[n] = lcdc_read(p, lcdc_shared_regs[n]); 1321 1322 /* turn off LCDC hardware */ 1323 lcdc_write(p, _LDCNT1R, 0); 1324 return 0; 1325} 1326 1327static int sh_mobile_lcdc_runtime_resume(struct device *dev) 1328{ 1329 struct platform_device *pdev = to_platform_device(dev); 1330 struct sh_mobile_lcdc_priv *p = platform_get_drvdata(pdev); 1331 struct sh_mobile_lcdc_chan *ch; 1332 int k, n; 1333 1334 /* restore per-channel registers */ 1335 for (k = 0; k < ARRAY_SIZE(p->ch); k++) { 1336 ch = &p->ch[k]; 1337 if (!ch->enabled) 1338 continue; 1339 for (n = 0; n < NR_CH_REGS; n++) 1340 lcdc_write_chan(ch, n, ch->saved_ch_regs[n]); 1341 } 1342 1343 /* restore shared registers */ 1344 for (n = 0; n < NR_SHARED_REGS; n++) 1345 lcdc_write(p, lcdc_shared_regs[n], p->saved_shared_regs[n]); 1346 1347 return 0; 1348} 1349 1350static const struct dev_pm_ops sh_mobile_lcdc_dev_pm_ops = { 1351 .suspend = sh_mobile_lcdc_suspend, 1352 .resume = sh_mobile_lcdc_resume, 1353 .runtime_suspend = sh_mobile_lcdc_runtime_suspend, 1354 .runtime_resume = sh_mobile_lcdc_runtime_resume, 1355}; 1356 1357/* locking: called with info->lock held */ 1358static int sh_mobile_lcdc_notify(struct notifier_block *nb, 1359 unsigned long action, void *data) 1360{ 1361 struct fb_event *event = data; 1362 struct fb_info *info = event->info; 1363 struct sh_mobile_lcdc_chan *ch = info->par; 1364 struct sh_mobile_lcdc_board_cfg *board_cfg = &ch->cfg.board_cfg; 1365 1366 if (&ch->lcdc->notifier != nb) 1367 return NOTIFY_DONE; 1368 1369 dev_dbg(info->dev, "%s(): action = %lu, data = %p\n", 1370 __func__, action, event->data); 1371 1372 switch(action) { 1373 case FB_EVENT_SUSPEND: 1374 if (board_cfg->display_off && try_module_get(board_cfg->owner)) { 1375 board_cfg->display_off(board_cfg->board_data); 1376 module_put(board_cfg->owner); 1377 } 1378 sh_mobile_lcdc_stop(ch->lcdc); 1379 break; 1380 case FB_EVENT_RESUME: 1381 mutex_lock(&ch->open_lock); 1382 sh_mobile_fb_reconfig(info); 1383 mutex_unlock(&ch->open_lock); 1384 1385 /* HDMI must be enabled before LCDC configuration */ 1386 if (board_cfg->display_on && try_module_get(board_cfg->owner)) { 1387 board_cfg->display_on(board_cfg->board_data, info); 1388 module_put(board_cfg->owner); 1389 } 1390 1391 sh_mobile_lcdc_start(ch->lcdc); 1392 } 1393 1394 return NOTIFY_OK; 1395} 1396 1397static int sh_mobile_lcdc_remove(struct platform_device *pdev); 1398 1399static int __devinit sh_mobile_lcdc_probe(struct platform_device *pdev) 1400{ 1401 struct fb_info *info; 1402 struct sh_mobile_lcdc_priv *priv; 1403 struct sh_mobile_lcdc_info *pdata = pdev->dev.platform_data; 1404 struct resource *res; 1405 int error; 1406 void *buf; 1407 int i, j; 1408 1409 if (!pdata) { 1410 dev_err(&pdev->dev, "no platform data defined\n"); 1411 return -EINVAL; 1412 } 1413 1414 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1415 i = platform_get_irq(pdev, 0); 1416 if (!res || i < 0) { 1417 dev_err(&pdev->dev, "cannot get platform resources\n"); 1418 return -ENOENT; 1419 } 1420 1421 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 1422 if (!priv) { 1423 dev_err(&pdev->dev, "cannot allocate device data\n"); 1424 return -ENOMEM; 1425 } 1426 1427 platform_set_drvdata(pdev, priv); 1428 1429 error = request_irq(i, sh_mobile_lcdc_irq, IRQF_DISABLED, 1430 dev_name(&pdev->dev), priv); 1431 if (error) { 1432 dev_err(&pdev->dev, "unable to request irq\n"); 1433 goto err1; 1434 } 1435 1436 priv->irq = i; 1437 atomic_set(&priv->hw_usecnt, -1); 1438 1439 j = 0; 1440 for (i = 0; i < ARRAY_SIZE(pdata->ch); i++) { 1441 struct sh_mobile_lcdc_chan *ch = priv->ch + j; 1442 1443 ch->lcdc = priv; 1444 memcpy(&ch->cfg, &pdata->ch[i], sizeof(pdata->ch[i])); 1445 1446 error = sh_mobile_lcdc_check_interface(ch); 1447 if (error) { 1448 dev_err(&pdev->dev, "unsupported interface type\n"); 1449 goto err1; 1450 } 1451 init_waitqueue_head(&ch->frame_end_wait); 1452 init_completion(&ch->vsync_completion); 1453 ch->pan_offset = 0; 1454 1455 /* probe the backlight is there is one defined */ 1456 if (ch->cfg.bl_info.max_brightness) 1457 ch->bl = sh_mobile_lcdc_bl_probe(&pdev->dev, ch); 1458 1459 switch (pdata->ch[i].chan) { 1460 case LCDC_CHAN_MAINLCD: 1461 ch->enabled = LDCNT2R_ME; 1462 ch->reg_offs = lcdc_offs_mainlcd; 1463 j++; 1464 break; 1465 case LCDC_CHAN_SUBLCD: 1466 ch->enabled = LDCNT2R_SE; 1467 ch->reg_offs = lcdc_offs_sublcd; 1468 j++; 1469 break; 1470 } 1471 } 1472 1473 if (!j) { 1474 dev_err(&pdev->dev, "no channels defined\n"); 1475 error = -EINVAL; 1476 goto err1; 1477 } 1478 1479 /* for dual channel LCDC (MAIN + SUB) force shared bpp setting */ 1480 if (j == 2) 1481 priv->forced_bpp = pdata->ch[0].bpp; 1482 1483 priv->base = ioremap_nocache(res->start, resource_size(res)); 1484 if (!priv->base) 1485 goto err1; 1486 1487 error = sh_mobile_lcdc_setup_clocks(pdev, pdata->clock_source, priv); 1488 if (error) { 1489 dev_err(&pdev->dev, "unable to setup clocks\n"); 1490 goto err1; 1491 } 1492 1493 priv->meram_dev = pdata->meram_dev; 1494 1495 for (i = 0; i < j; i++) { 1496 struct fb_var_screeninfo *var; 1497 const struct fb_videomode *lcd_cfg, *max_cfg = NULL; 1498 struct sh_mobile_lcdc_chan *ch = priv->ch + i; 1499 struct sh_mobile_lcdc_chan_cfg *cfg = &ch->cfg; 1500 const struct fb_videomode *mode = cfg->lcd_cfg; 1501 unsigned long max_size = 0; 1502 int k; 1503 int num_cfg; 1504 1505 ch->info = framebuffer_alloc(0, &pdev->dev); 1506 if (!ch->info) { 1507 dev_err(&pdev->dev, "unable to allocate fb_info\n"); 1508 error = -ENOMEM; 1509 break; 1510 } 1511 1512 info = ch->info; 1513 var = &info->var; 1514 info->fbops = &sh_mobile_lcdc_ops; 1515 info->par = ch; 1516 1517 mutex_init(&ch->open_lock); 1518 1519 for (k = 0, lcd_cfg = mode; 1520 k < cfg->num_cfg && lcd_cfg; 1521 k++, lcd_cfg++) { 1522 unsigned long size = lcd_cfg->yres * lcd_cfg->xres; 1523 /* NV12 buffers must have even number of lines */ 1524 if ((cfg->nonstd) && cfg->bpp == 12 && 1525 (lcd_cfg->yres & 0x1)) { 1526 dev_err(&pdev->dev, "yres must be multiple of 2" 1527 " for YCbCr420 mode.\n"); 1528 error = -EINVAL; 1529 goto err1; 1530 } 1531 1532 if (size > max_size) { 1533 max_cfg = lcd_cfg; 1534 max_size = size; 1535 } 1536 } 1537 1538 if (!mode) 1539 max_size = MAX_XRES * MAX_YRES; 1540 else if (max_cfg) 1541 dev_dbg(&pdev->dev, "Found largest videomode %ux%u\n", 1542 max_cfg->xres, max_cfg->yres); 1543 1544 info->fix = sh_mobile_lcdc_fix; 1545 info->fix.smem_len = max_size * 2 * cfg->bpp / 8; 1546 1547 /* Only pan in 2 line steps for NV12 */ 1548 if (cfg->nonstd && cfg->bpp == 12) 1549 info->fix.ypanstep = 2; 1550 1551 if (!mode) { 1552 mode = &default_720p; 1553 num_cfg = 1; 1554 } else { 1555 num_cfg = cfg->num_cfg; 1556 } 1557 1558 fb_videomode_to_modelist(mode, num_cfg, &info->modelist); 1559 1560 fb_videomode_to_var(var, mode); 1561 var->width = cfg->lcd_size_cfg.width; 1562 var->height = cfg->lcd_size_cfg.height; 1563 /* Default Y virtual resolution is 2x panel size */ 1564 var->yres_virtual = var->yres * 2; 1565 var->activate = FB_ACTIVATE_NOW; 1566 1567 error = sh_mobile_lcdc_set_bpp(var, cfg->bpp, cfg->nonstd); 1568 if (error) 1569 break; 1570 1571 buf = dma_alloc_coherent(&pdev->dev, info->fix.smem_len, 1572 &ch->dma_handle, GFP_KERNEL); 1573 if (!buf) { 1574 dev_err(&pdev->dev, "unable to allocate buffer\n"); 1575 error = -ENOMEM; 1576 break; 1577 } 1578 1579 info->pseudo_palette = &ch->pseudo_palette; 1580 info->flags = FBINFO_FLAG_DEFAULT; 1581 1582 error = fb_alloc_cmap(&info->cmap, PALETTE_NR, 0); 1583 if (error < 0) { 1584 dev_err(&pdev->dev, "unable to allocate cmap\n"); 1585 dma_free_coherent(&pdev->dev, info->fix.smem_len, 1586 buf, ch->dma_handle); 1587 break; 1588 } 1589 1590 info->fix.smem_start = ch->dma_handle; 1591 if (var->nonstd) 1592 info->fix.line_length = var->xres; 1593 else 1594 info->fix.line_length = var->xres * (cfg->bpp / 8); 1595 1596 info->screen_base = buf; 1597 info->device = &pdev->dev; 1598 ch->display_var = *var; 1599 } 1600 1601 if (error) 1602 goto err1; 1603 1604 error = sh_mobile_lcdc_start(priv); 1605 if (error) { 1606 dev_err(&pdev->dev, "unable to start hardware\n"); 1607 goto err1; 1608 } 1609 1610 for (i = 0; i < j; i++) { 1611 struct sh_mobile_lcdc_chan *ch = priv->ch + i; 1612 1613 info = ch->info; 1614 1615 if (info->fbdefio) { 1616 ch->sglist = vmalloc(sizeof(struct scatterlist) * 1617 info->fix.smem_len >> PAGE_SHIFT); 1618 if (!ch->sglist) { 1619 dev_err(&pdev->dev, "cannot allocate sglist\n"); 1620 goto err1; 1621 } 1622 } 1623 1624 info->bl_dev = ch->bl; 1625 1626 error = register_framebuffer(info); 1627 if (error < 0) 1628 goto err1; 1629 1630 dev_info(info->dev, 1631 "registered %s/%s as %dx%d %dbpp.\n", 1632 pdev->name, 1633 (ch->cfg.chan == LCDC_CHAN_MAINLCD) ? 1634 "mainlcd" : "sublcd", 1635 info->var.xres, info->var.yres, 1636 ch->cfg.bpp); 1637 1638 /* deferred io mode: disable clock to save power */ 1639 if (info->fbdefio || info->state == FBINFO_STATE_SUSPENDED) 1640 sh_mobile_lcdc_clk_off(priv); 1641 } 1642 1643 /* Failure ignored */ 1644 priv->notifier.notifier_call = sh_mobile_lcdc_notify; 1645 fb_register_client(&priv->notifier); 1646 1647 return 0; 1648err1: 1649 sh_mobile_lcdc_remove(pdev); 1650 1651 return error; 1652} 1653 1654static int sh_mobile_lcdc_remove(struct platform_device *pdev) 1655{ 1656 struct sh_mobile_lcdc_priv *priv = platform_get_drvdata(pdev); 1657 struct fb_info *info; 1658 int i; 1659 1660 fb_unregister_client(&priv->notifier); 1661 1662 for (i = 0; i < ARRAY_SIZE(priv->ch); i++) 1663 if (priv->ch[i].info && priv->ch[i].info->dev) 1664 unregister_framebuffer(priv->ch[i].info); 1665 1666 sh_mobile_lcdc_stop(priv); 1667 1668 for (i = 0; i < ARRAY_SIZE(priv->ch); i++) { 1669 info = priv->ch[i].info; 1670 1671 if (!info || !info->device) 1672 continue; 1673 1674 if (priv->ch[i].sglist) 1675 vfree(priv->ch[i].sglist); 1676 1677 if (info->screen_base) 1678 dma_free_coherent(&pdev->dev, info->fix.smem_len, 1679 info->screen_base, 1680 priv->ch[i].dma_handle); 1681 fb_dealloc_cmap(&info->cmap); 1682 framebuffer_release(info); 1683 } 1684 1685 for (i = 0; i < ARRAY_SIZE(priv->ch); i++) { 1686 if (priv->ch[i].bl) 1687 sh_mobile_lcdc_bl_remove(priv->ch[i].bl); 1688 } 1689 1690 if (priv->dot_clk) 1691 clk_put(priv->dot_clk); 1692 1693 if (priv->dev) 1694 pm_runtime_disable(priv->dev); 1695 1696 if (priv->base) 1697 iounmap(priv->base); 1698 1699 if (priv->irq) 1700 free_irq(priv->irq, priv); 1701 kfree(priv); 1702 return 0; 1703} 1704 1705static struct platform_driver sh_mobile_lcdc_driver = { 1706 .driver = { 1707 .name = "sh_mobile_lcdc_fb", 1708 .owner = THIS_MODULE, 1709 .pm = &sh_mobile_lcdc_dev_pm_ops, 1710 }, 1711 .probe = sh_mobile_lcdc_probe, 1712 .remove = sh_mobile_lcdc_remove, 1713}; 1714 1715static int __init sh_mobile_lcdc_init(void) 1716{ 1717 return platform_driver_register(&sh_mobile_lcdc_driver); 1718} 1719 1720static void __exit sh_mobile_lcdc_exit(void) 1721{ 1722 platform_driver_unregister(&sh_mobile_lcdc_driver); 1723} 1724 1725module_init(sh_mobile_lcdc_init); 1726module_exit(sh_mobile_lcdc_exit); 1727 1728MODULE_DESCRIPTION("SuperH Mobile LCDC Framebuffer driver"); 1729MODULE_AUTHOR("Magnus Damm <damm@opensource.se>"); 1730MODULE_LICENSE("GPL v2"); 1731