projects / deliverable / linux.git / blob
? search:


d0c90269922232685c319a946a375b6c7c0140ef
[deliverable/linux.git] / drivers / video / sh_mobile_lcdcfb.c
1 /*
2 * SuperH Mobile LCDC Framebuffer
3 *
4 * Copyright (c) 2008 Magnus Damm
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
8 * for more details.
9 */
10
11 #include <linux/atomic.h>
12 #include <linux/backlight.h>
13 #include <linux/clk.h>
14 #include <linux/console.h>
15 #include <linux/dma-mapping.h>
16 #include <linux/delay.h>
17 #include <linux/gpio.h>
18 #include <linux/init.h>
19 #include <linux/interrupt.h>
20 #include <linux/ioctl.h>
21 #include <linux/kernel.h>
22 #include <linux/mm.h>
23 #include <linux/module.h>
24 #include <linux/platform_device.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/slab.h>
27 #include <linux/videodev2.h>
28 #include <linux/vmalloc.h>
29
30 #include <video/sh_mobile_lcdc.h>
31 #include <video/sh_mobile_meram.h>
32
33 #include "sh_mobile_lcdcfb.h"
34
35 #define SIDE_B_OFFSET 0x1000
36 #define MIRROR_OFFSET 0x2000
37
38 #define MAX_XRES 1920
39 #define MAX_YRES 1080
40
41 struct sh_mobile_lcdc_priv {
42 void __iomem *base;
43 int irq;
44 atomic_t hw_usecnt;
45 struct device *dev;
46 struct clk *dot_clk;
47 unsigned long lddckr;
48 struct sh_mobile_lcdc_chan ch[2];
49 struct notifier_block notifier;
50 int started;
51 int forced_fourcc; /* 2 channel LCDC must share fourcc setting */
52 struct sh_mobile_meram_info *meram_dev;
53 };
54
55 /* -----------------------------------------------------------------------------
56 * Registers access
57 */
58
59 static unsigned long lcdc_offs_mainlcd[NR_CH_REGS] = {
60 [LDDCKPAT1R] = 0x400,
61 [LDDCKPAT2R] = 0x404,
62 [LDMT1R] = 0x418,
63 [LDMT2R] = 0x41c,
64 [LDMT3R] = 0x420,
65 [LDDFR] = 0x424,
66 [LDSM1R] = 0x428,
67 [LDSM2R] = 0x42c,
68 [LDSA1R] = 0x430,
69 [LDSA2R] = 0x434,
70 [LDMLSR] = 0x438,
71 [LDHCNR] = 0x448,
72 [LDHSYNR] = 0x44c,
73 [LDVLNR] = 0x450,
74 [LDVSYNR] = 0x454,
75 [LDPMR] = 0x460,
76 [LDHAJR] = 0x4a0,
77 };
78
79 static unsigned long lcdc_offs_sublcd[NR_CH_REGS] = {
80 [LDDCKPAT1R] = 0x408,
81 [LDDCKPAT2R] = 0x40c,
82 [LDMT1R] = 0x600,
83 [LDMT2R] = 0x604,
84 [LDMT3R] = 0x608,
85 [LDDFR] = 0x60c,
86 [LDSM1R] = 0x610,
87 [LDSM2R] = 0x614,
88 [LDSA1R] = 0x618,
89 [LDMLSR] = 0x620,
90 [LDHCNR] = 0x624,
91 [LDHSYNR] = 0x628,
92 [LDVLNR] = 0x62c,
93 [LDVSYNR] = 0x630,
94 [LDPMR] = 0x63c,
95 };
96
97 static bool banked(int reg_nr)
98 {
99 switch (reg_nr) {
100 case LDMT1R:
101 case LDMT2R:
102 case LDMT3R:
103 case LDDFR:
104 case LDSM1R:
105 case LDSA1R:
106 case LDSA2R:
107 case LDMLSR:
108 case LDHCNR:
109 case LDHSYNR:
110 case LDVLNR:
111 case LDVSYNR:
112 return true;
113 }
114 return false;
115 }
116
117 static int lcdc_chan_is_sublcd(struct sh_mobile_lcdc_chan *chan)
118 {
119 return chan->cfg.chan == LCDC_CHAN_SUBLCD;
120 }
121
122 static void lcdc_write_chan(struct sh_mobile_lcdc_chan *chan,
123 int reg_nr, unsigned long data)
124 {
125 iowrite32(data, chan->lcdc->base + chan->reg_offs[reg_nr]);
126 if (banked(reg_nr))
127 iowrite32(data, chan->lcdc->base + chan->reg_offs[reg_nr] +
128 SIDE_B_OFFSET);
129 }
130
131 static void lcdc_write_chan_mirror(struct sh_mobile_lcdc_chan *chan,
132 int reg_nr, unsigned long data)
133 {
134 iowrite32(data, chan->lcdc->base + chan->reg_offs[reg_nr] +
135 MIRROR_OFFSET);
136 }
137
138 static unsigned long lcdc_read_chan(struct sh_mobile_lcdc_chan *chan,
139 int reg_nr)
140 {
141 return ioread32(chan->lcdc->base + chan->reg_offs[reg_nr]);
142 }
143
144 static void lcdc_write(struct sh_mobile_lcdc_priv *priv,
145 unsigned long reg_offs, unsigned long data)
146 {
147 iowrite32(data, priv->base + reg_offs);
148 }
149
150 static unsigned long lcdc_read(struct sh_mobile_lcdc_priv *priv,
151 unsigned long reg_offs)
152 {
153 return ioread32(priv->base + reg_offs);
154 }
155
156 static void lcdc_wait_bit(struct sh_mobile_lcdc_priv *priv,
157 unsigned long reg_offs,
158 unsigned long mask, unsigned long until)
159 {
160 while ((lcdc_read(priv, reg_offs) & mask) != until)
161 cpu_relax();
162 }
163
164 /* -----------------------------------------------------------------------------
165 * Clock management
166 */
167
168 static void sh_mobile_lcdc_clk_on(struct sh_mobile_lcdc_priv *priv)
169 {
170 if (atomic_inc_and_test(&priv->hw_usecnt)) {
171 if (priv->dot_clk)
172 clk_enable(priv->dot_clk);
173 pm_runtime_get_sync(priv->dev);
174 if (priv->meram_dev && priv->meram_dev->pdev)
175 pm_runtime_get_sync(&priv->meram_dev->pdev->dev);
176 }
177 }
178
179 static void sh_mobile_lcdc_clk_off(struct sh_mobile_lcdc_priv *priv)
180 {
181 if (atomic_sub_return(1, &priv->hw_usecnt) == -1) {
182 if (priv->meram_dev && priv->meram_dev->pdev)
183 pm_runtime_put_sync(&priv->meram_dev->pdev->dev);
184 pm_runtime_put(priv->dev);
185 if (priv->dot_clk)
186 clk_disable(priv->dot_clk);
187 }
188 }
189
190 static int sh_mobile_lcdc_setup_clocks(struct sh_mobile_lcdc_priv *priv,
191 int clock_source)
192 {
193 struct clk *clk;
194 char *str;
195
196 switch (clock_source) {
197 case LCDC_CLK_BUS:
198 str = "bus_clk";
199 priv->lddckr = LDDCKR_ICKSEL_BUS;
200 break;
201 case LCDC_CLK_PERIPHERAL:
202 str = "peripheral_clk";
203 priv->lddckr = LDDCKR_ICKSEL_MIPI;
204 break;
205 case LCDC_CLK_EXTERNAL:
206 str = NULL;
207 priv->lddckr = LDDCKR_ICKSEL_HDMI;
208 break;
209 default:
210 return -EINVAL;
211 }
212
213 if (str == NULL)
214 return 0;
215
216 clk = clk_get(priv->dev, str);
217 if (IS_ERR(clk)) {
218 dev_err(priv->dev, "cannot get dot clock %s\n", str);
219 return PTR_ERR(clk);
220 }
221
222 priv->dot_clk = clk;
223 return 0;
224 }
225
226 /* -----------------------------------------------------------------------------
227 * Display, panel and deferred I/O
228 */
229
230 static void lcdc_sys_write_index(void *handle, unsigned long data)
231 {
232 struct sh_mobile_lcdc_chan *ch = handle;
233
234 lcdc_write(ch->lcdc, _LDDWD0R, data | LDDWDxR_WDACT);
235 lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0);
236 lcdc_write(ch->lcdc, _LDDWAR, LDDWAR_WA |
237 (lcdc_chan_is_sublcd(ch) ? 2 : 0));
238 lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0);
239 }
240
241 static void lcdc_sys_write_data(void *handle, unsigned long data)
242 {
243 struct sh_mobile_lcdc_chan *ch = handle;
244
245 lcdc_write(ch->lcdc, _LDDWD0R, data | LDDWDxR_WDACT | LDDWDxR_RSW);
246 lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0);
247 lcdc_write(ch->lcdc, _LDDWAR, LDDWAR_WA |
248 (lcdc_chan_is_sublcd(ch) ? 2 : 0));
249 lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0);
250 }
251
252 static unsigned long lcdc_sys_read_data(void *handle)
253 {
254 struct sh_mobile_lcdc_chan *ch = handle;
255
256 lcdc_write(ch->lcdc, _LDDRDR, LDDRDR_RSR);
257 lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0);
258 lcdc_write(ch->lcdc, _LDDRAR, LDDRAR_RA |
259 (lcdc_chan_is_sublcd(ch) ? 2 : 0));
260 udelay(1);
261 lcdc_wait_bit(ch->lcdc, _LDSR, LDSR_AS, 0);
262
263 return lcdc_read(ch->lcdc, _LDDRDR) & LDDRDR_DRD_MASK;
264 }
265
266 struct sh_mobile_lcdc_sys_bus_ops sh_mobile_lcdc_sys_bus_ops = {
267 lcdc_sys_write_index,
268 lcdc_sys_write_data,
269 lcdc_sys_read_data,
270 };
271
272 static int sh_mobile_lcdc_sginit(struct fb_info *info,
273 struct list_head *pagelist)
274 {
275 struct sh_mobile_lcdc_chan *ch = info->par;
276 unsigned int nr_pages_max = ch->fb_size >> PAGE_SHIFT;
277 struct page *page;
278 int nr_pages = 0;
279
280 sg_init_table(ch->sglist, nr_pages_max);
281
282 list_for_each_entry(page, pagelist, lru)
283 sg_set_page(&ch->sglist[nr_pages++], page, PAGE_SIZE, 0);
284
285 return nr_pages;
286 }
287
288 static void sh_mobile_lcdc_deferred_io(struct fb_info *info,
289 struct list_head *pagelist)
290 {
291 struct sh_mobile_lcdc_chan *ch = info->par;
292 struct sh_mobile_lcdc_panel_cfg *panel = &ch->cfg.panel_cfg;
293
294 /* enable clocks before accessing hardware */
295 sh_mobile_lcdc_clk_on(ch->lcdc);
296
297 /*
298 * It's possible to get here without anything on the pagelist via
299 * sh_mobile_lcdc_deferred_io_touch() or via a userspace fsync()
300 * invocation. In the former case, the acceleration routines are
301 * stepped in to when using the framebuffer console causing the
302 * workqueue to be scheduled without any dirty pages on the list.
303 *
304 * Despite this, a panel update is still needed given that the
305 * acceleration routines have their own methods for writing in
306 * that still need to be updated.
307 *
308 * The fsync() and empty pagelist case could be optimized for,
309 * but we don't bother, as any application exhibiting such
310 * behaviour is fundamentally broken anyways.
311 */
312 if (!list_empty(pagelist)) {
313 unsigned int nr_pages = sh_mobile_lcdc_sginit(info, pagelist);
314
315 /* trigger panel update */
316 dma_map_sg(ch->lcdc->dev, ch->sglist, nr_pages, DMA_TO_DEVICE);
317 if (panel->start_transfer)
318 panel->start_transfer(ch, &sh_mobile_lcdc_sys_bus_ops);
319 lcdc_write_chan(ch, LDSM2R, LDSM2R_OSTRG);
320 dma_unmap_sg(ch->lcdc->dev, ch->sglist, nr_pages,
321 DMA_TO_DEVICE);
322 } else {
323 if (panel->start_transfer)
324 panel->start_transfer(ch, &sh_mobile_lcdc_sys_bus_ops);
325 lcdc_write_chan(ch, LDSM2R, LDSM2R_OSTRG);
326 }
327 }
328
329 static void sh_mobile_lcdc_deferred_io_touch(struct fb_info *info)
330 {
331 struct fb_deferred_io *fbdefio = info->fbdefio;
332
333 if (fbdefio)
334 schedule_delayed_work(&info->deferred_work, fbdefio->delay);
335 }
336
337 static void sh_mobile_lcdc_display_on(struct sh_mobile_lcdc_chan *ch)
338 {
339 struct sh_mobile_lcdc_panel_cfg *panel = &ch->cfg.panel_cfg;
340
341 if (ch->tx_dev) {
342 int ret;
343
344 ret = ch->tx_dev->ops->display_on(ch->tx_dev);
345 if (ret < 0)
346 return;
347
348 if (ret == SH_MOBILE_LCDC_DISPLAY_DISCONNECTED)
349 ch->info->state = FBINFO_STATE_SUSPENDED;
350 }
351
352 /* HDMI must be enabled before LCDC configuration */
353 if (panel->display_on)
354 panel->display_on();
355 }
356
357 static void sh_mobile_lcdc_display_off(struct sh_mobile_lcdc_chan *ch)
358 {
359 struct sh_mobile_lcdc_panel_cfg *panel = &ch->cfg.panel_cfg;
360
361 if (panel->display_off)
362 panel->display_off();
363
364 if (ch->tx_dev)
365 ch->tx_dev->ops->display_off(ch->tx_dev);
366 }
367
368 static bool
369 sh_mobile_lcdc_must_reconfigure(struct sh_mobile_lcdc_chan *ch,
370 const struct fb_videomode *new_mode)
371 {
372 dev_dbg(ch->info->dev, "Old %ux%u, new %ux%u\n",
373 ch->display.mode.xres, ch->display.mode.yres,
374 new_mode->xres, new_mode->yres);
375
376 /* It can be a different monitor with an equal video-mode */
377 if (fb_mode_is_equal(&ch->display.mode, new_mode))
378 return false;
379
380 dev_dbg(ch->info->dev, "Switching %u -> %u lines\n",
381 ch->display.mode.yres, new_mode->yres);
382 ch->display.mode = *new_mode;
383
384 return true;
385 }
386
387 static int sh_mobile_check_var(struct fb_var_screeninfo *var,
388 struct fb_info *info);
389
390 static int sh_mobile_lcdc_display_notify(struct sh_mobile_lcdc_chan *ch,
391 enum sh_mobile_lcdc_entity_event event,
392 const struct fb_videomode *mode,
393 const struct fb_monspecs *monspec)
394 {
395 struct fb_info *info = ch->info;
396 struct fb_var_screeninfo var;
397 int ret = 0;
398
399 switch (event) {
400 case SH_MOBILE_LCDC_EVENT_DISPLAY_CONNECT:
401 /* HDMI plug in */
402 if (lock_fb_info(info)) {
403 console_lock();
404
405 ch->display.width = monspec->max_x * 10;
406 ch->display.height = monspec->max_y * 10;
407
408 if (!sh_mobile_lcdc_must_reconfigure(ch, mode) &&
409 info->state == FBINFO_STATE_RUNNING) {
410 /* First activation with the default monitor.
411 * Just turn on, if we run a resume here, the
412 * logo disappears.
413 */
414 info->var.width = monspec->max_x * 10;
415 info->var.height = monspec->max_y * 10;
416 sh_mobile_lcdc_display_on(ch);
417 } else {
418 /* New monitor or have to wake up */
419 fb_set_suspend(info, 0);
420 }
421
422 console_unlock();
423 unlock_fb_info(info);
424 }
425 break;
426
427 case SH_MOBILE_LCDC_EVENT_DISPLAY_DISCONNECT:
428 /* HDMI disconnect */
429 if (lock_fb_info(info)) {
430 console_lock();
431 fb_set_suspend(info, 1);
432 console_unlock();
433 unlock_fb_info(info);
434 }
435 break;
436
437 case SH_MOBILE_LCDC_EVENT_DISPLAY_MODE:
438 /* Validate a proposed new mode */
439 fb_videomode_to_var(&var, mode);
440 var.bits_per_pixel = info->var.bits_per_pixel;
441 var.grayscale = info->var.grayscale;
442 ret = sh_mobile_check_var(&var, info);
443 break;
444 }
445
446 return ret;
447 }
448
449 /* -----------------------------------------------------------------------------
450 * Format helpers
451 */
452
453 struct sh_mobile_lcdc_format_info {
454 u32 fourcc;
455 unsigned int bpp;
456 bool yuv;
457 u32 lddfr;
458 };
459
460 static const struct sh_mobile_lcdc_format_info sh_mobile_format_infos[] = {
461 {
462 .fourcc = V4L2_PIX_FMT_RGB565,
463 .bpp = 16,
464 .yuv = false,
465 .lddfr = LDDFR_PKF_RGB16,
466 }, {
467 .fourcc = V4L2_PIX_FMT_BGR24,
468 .bpp = 24,
469 .yuv = false,
470 .lddfr = LDDFR_PKF_RGB24,
471 }, {
472 .fourcc = V4L2_PIX_FMT_BGR32,
473 .bpp = 32,
474 .yuv = false,
475 .lddfr = LDDFR_PKF_ARGB32,
476 }, {
477 .fourcc = V4L2_PIX_FMT_NV12,
478 .bpp = 12,
479 .yuv = true,
480 .lddfr = LDDFR_CC | LDDFR_YF_420,
481 }, {
482 .fourcc = V4L2_PIX_FMT_NV21,
483 .bpp = 12,
484 .yuv = true,
485 .lddfr = LDDFR_CC | LDDFR_YF_420,
486 }, {
487 .fourcc = V4L2_PIX_FMT_NV16,
488 .bpp = 16,
489 .yuv = true,
490 .lddfr = LDDFR_CC | LDDFR_YF_422,
491 }, {
492 .fourcc = V4L2_PIX_FMT_NV61,
493 .bpp = 16,
494 .yuv = true,
495 .lddfr = LDDFR_CC | LDDFR_YF_422,
496 }, {
497 .fourcc = V4L2_PIX_FMT_NV24,
498 .bpp = 24,
499 .yuv = true,
500 .lddfr = LDDFR_CC | LDDFR_YF_444,
501 }, {
502 .fourcc = V4L2_PIX_FMT_NV42,
503 .bpp = 24,
504 .yuv = true,
505 .lddfr = LDDFR_CC | LDDFR_YF_444,
506 },
507 };
508
509 static const struct sh_mobile_lcdc_format_info *
510 sh_mobile_format_info(u32 fourcc)
511 {
512 unsigned int i;
513
514 for (i = 0; i < ARRAY_SIZE(sh_mobile_format_infos); ++i) {
515 if (sh_mobile_format_infos[i].fourcc == fourcc)
516 return &sh_mobile_format_infos[i];
517 }
518
519 return NULL;
520 }
521
522 static int sh_mobile_format_fourcc(const struct fb_var_screeninfo *var)
523 {
524 if (var->grayscale > 1)
525 return var->grayscale;
526
527 switch (var->bits_per_pixel) {
528 case 16:
529 return V4L2_PIX_FMT_RGB565;
530 case 24:
531 return V4L2_PIX_FMT_BGR24;
532 case 32:
533 return V4L2_PIX_FMT_BGR32;
534 default:
535 return 0;
536 }
537 }
538
539 static int sh_mobile_format_is_fourcc(const struct fb_var_screeninfo *var)
540 {
541 return var->grayscale > 1;
542 }
543
544 /* -----------------------------------------------------------------------------
545 * Start, stop and IRQ
546 */
547
548 static irqreturn_t sh_mobile_lcdc_irq(int irq, void *data)
549 {
550 struct sh_mobile_lcdc_priv *priv = data;
551 struct sh_mobile_lcdc_chan *ch;
552 unsigned long ldintr;
553 int is_sub;
554 int k;
555
556 /* Acknowledge interrupts and disable further VSYNC End IRQs. */
557 ldintr = lcdc_read(priv, _LDINTR);
558 lcdc_write(priv, _LDINTR, (ldintr ^ LDINTR_STATUS_MASK) & ~LDINTR_VEE);
559
560 /* figure out if this interrupt is for main or sub lcd */
561 is_sub = (lcdc_read(priv, _LDSR) & LDSR_MSS) ? 1 : 0;
562
563 /* wake up channel and disable clocks */
564 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
565 ch = &priv->ch[k];
566
567 if (!ch->enabled)
568 continue;
569
570 /* Frame End */
571 if (ldintr & LDINTR_FS) {
572 if (is_sub == lcdc_chan_is_sublcd(ch)) {
573 ch->frame_end = 1;
574 wake_up(&ch->frame_end_wait);
575
576 sh_mobile_lcdc_clk_off(priv);
577 }
578 }
579
580 /* VSYNC End */
581 if (ldintr & LDINTR_VES)
582 complete(&ch->vsync_completion);
583 }
584
585 return IRQ_HANDLED;
586 }
587
588 static int sh_mobile_wait_for_vsync(struct sh_mobile_lcdc_chan *ch)
589 {
590 unsigned long ldintr;
591 int ret;
592
593 /* Enable VSync End interrupt and be careful not to acknowledge any
594 * pending interrupt.
595 */
596 ldintr = lcdc_read(ch->lcdc, _LDINTR);
597 ldintr |= LDINTR_VEE | LDINTR_STATUS_MASK;
598 lcdc_write(ch->lcdc, _LDINTR, ldintr);
599
600 ret = wait_for_completion_interruptible_timeout(&ch->vsync_completion,
601 msecs_to_jiffies(100));
602 if (!ret)
603 return -ETIMEDOUT;
604
605 return 0;
606 }
607
608 static void sh_mobile_lcdc_start_stop(struct sh_mobile_lcdc_priv *priv,
609 int start)
610 {
611 unsigned long tmp = lcdc_read(priv, _LDCNT2R);
612 int k;
613
614 /* start or stop the lcdc */
615 if (start)
616 lcdc_write(priv, _LDCNT2R, tmp | LDCNT2R_DO);
617 else
618 lcdc_write(priv, _LDCNT2R, tmp & ~LDCNT2R_DO);
619
620 /* wait until power is applied/stopped on all channels */
621 for (k = 0; k < ARRAY_SIZE(priv->ch); k++)
622 if (lcdc_read(priv, _LDCNT2R) & priv->ch[k].enabled)
623 while (1) {
624 tmp = lcdc_read_chan(&priv->ch[k], LDPMR)
625 & LDPMR_LPS;
626 if (start && tmp == LDPMR_LPS)
627 break;
628 if (!start && tmp == 0)
629 break;
630 cpu_relax();
631 }
632
633 if (!start)
634 lcdc_write(priv, _LDDCKSTPR, 1); /* stop dotclock */
635 }
636
637 static void sh_mobile_lcdc_geometry(struct sh_mobile_lcdc_chan *ch)
638 {
639 const struct fb_var_screeninfo *var = &ch->info->var;
640 const struct fb_videomode *mode = &ch->display.mode;
641 unsigned long h_total, hsync_pos, display_h_total;
642 u32 tmp;
643
644 tmp = ch->ldmt1r_value;
645 tmp |= (var->sync & FB_SYNC_VERT_HIGH_ACT) ? 0 : LDMT1R_VPOL;
646 tmp |= (var->sync & FB_SYNC_HOR_HIGH_ACT) ? 0 : LDMT1R_HPOL;
647 tmp |= (ch->cfg.flags & LCDC_FLAGS_DWPOL) ? LDMT1R_DWPOL : 0;
648 tmp |= (ch->cfg.flags & LCDC_FLAGS_DIPOL) ? LDMT1R_DIPOL : 0;
649 tmp |= (ch->cfg.flags & LCDC_FLAGS_DAPOL) ? LDMT1R_DAPOL : 0;
650 tmp |= (ch->cfg.flags & LCDC_FLAGS_HSCNT) ? LDMT1R_HSCNT : 0;
651 tmp |= (ch->cfg.flags & LCDC_FLAGS_DWCNT) ? LDMT1R_DWCNT : 0;
652 lcdc_write_chan(ch, LDMT1R, tmp);
653
654 /* setup SYS bus */
655 lcdc_write_chan(ch, LDMT2R, ch->cfg.sys_bus_cfg.ldmt2r);
656 lcdc_write_chan(ch, LDMT3R, ch->cfg.sys_bus_cfg.ldmt3r);
657
658 /* horizontal configuration */
659 h_total = mode->xres + mode->hsync_len + mode->left_margin
660 + mode->right_margin;
661 tmp = h_total / 8; /* HTCN */
662 tmp |= (min(mode->xres, ch->xres) / 8) << 16; /* HDCN */
663 lcdc_write_chan(ch, LDHCNR, tmp);
664
665 hsync_pos = mode->xres + mode->right_margin;
666 tmp = hsync_pos / 8; /* HSYNP */
667 tmp |= (mode->hsync_len / 8) << 16; /* HSYNW */
668 lcdc_write_chan(ch, LDHSYNR, tmp);
669
670 /* vertical configuration */
671 tmp = mode->yres + mode->vsync_len + mode->upper_margin
672 + mode->lower_margin; /* VTLN */
673 tmp |= min(mode->yres, ch->yres) << 16; /* VDLN */
674 lcdc_write_chan(ch, LDVLNR, tmp);
675
676 tmp = mode->yres + mode->lower_margin; /* VSYNP */
677 tmp |= mode->vsync_len << 16; /* VSYNW */
678 lcdc_write_chan(ch, LDVSYNR, tmp);
679
680 /* Adjust horizontal synchronisation for HDMI */
681 display_h_total = mode->xres + mode->hsync_len + mode->left_margin
682 + mode->right_margin;
683 tmp = ((mode->xres & 7) << 24) | ((display_h_total & 7) << 16)
684 | ((mode->hsync_len & 7) << 8) | (hsync_pos & 7);
685 lcdc_write_chan(ch, LDHAJR, tmp);
686 }
687
688 /*
689 * __sh_mobile_lcdc_start - Configure and tart the LCDC
690 * @priv: LCDC device
691 *
692 * Configure all enabled channels and start the LCDC device. All external
693 * devices (clocks, MERAM, panels, ...) are not touched by this function.
694 */
695 static void __sh_mobile_lcdc_start(struct sh_mobile_lcdc_priv *priv)
696 {
697 struct sh_mobile_lcdc_chan *ch;
698 unsigned long tmp;
699 int k, m;
700
701 /* Enable LCDC channels. Read data from external memory, avoid using the
702 * BEU for now.
703 */
704 lcdc_write(priv, _LDCNT2R, priv->ch[0].enabled | priv->ch[1].enabled);
705
706 /* Stop the LCDC first and disable all interrupts. */
707 sh_mobile_lcdc_start_stop(priv, 0);
708 lcdc_write(priv, _LDINTR, 0);
709
710 /* Configure power supply, dot clocks and start them. */
711 tmp = priv->lddckr;
712 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
713 ch = &priv->ch[k];
714 if (!ch->enabled)
715 continue;
716
717 /* Power supply */
718 lcdc_write_chan(ch, LDPMR, 0);
719
720 m = ch->cfg.clock_divider;
721 if (!m)
722 continue;
723
724 /* FIXME: sh7724 can only use 42, 48, 54 and 60 for the divider
725 * denominator.
726 */
727 lcdc_write_chan(ch, LDDCKPAT1R, 0);
728 lcdc_write_chan(ch, LDDCKPAT2R, (1 << (m/2)) - 1);
729
730 if (m == 1)
731 m = LDDCKR_MOSEL;
732 tmp |= m << (lcdc_chan_is_sublcd(ch) ? 8 : 0);
733 }
734
735 lcdc_write(priv, _LDDCKR, tmp);
736 lcdc_write(priv, _LDDCKSTPR, 0);
737 lcdc_wait_bit(priv, _LDDCKSTPR, ~0, 0);
738
739 /* Setup geometry, format, frame buffer memory and operation mode. */
740 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
741 ch = &priv->ch[k];
742 if (!ch->enabled)
743 continue;
744
745 sh_mobile_lcdc_geometry(ch);
746
747 tmp = ch->format->lddfr;
748
749 if (ch->format->yuv) {
750 switch (ch->colorspace) {
751 case V4L2_COLORSPACE_REC709:
752 tmp |= LDDFR_CF1;
753 break;
754 case V4L2_COLORSPACE_JPEG:
755 tmp |= LDDFR_CF0;
756 break;
757 }
758 }
759
760 lcdc_write_chan(ch, LDDFR, tmp);
761 lcdc_write_chan(ch, LDMLSR, ch->pitch);
762 lcdc_write_chan(ch, LDSA1R, ch->base_addr_y);
763 if (ch->format->yuv)
764 lcdc_write_chan(ch, LDSA2R, ch->base_addr_c);
765
766 /* When using deferred I/O mode, configure the LCDC for one-shot
767 * operation and enable the frame end interrupt. Otherwise use
768 * continuous read mode.
769 */
770 if (ch->ldmt1r_value & LDMT1R_IFM &&
771 ch->cfg.sys_bus_cfg.deferred_io_msec) {
772 lcdc_write_chan(ch, LDSM1R, LDSM1R_OS);
773 lcdc_write(priv, _LDINTR, LDINTR_FE);
774 } else {
775 lcdc_write_chan(ch, LDSM1R, 0);
776 }
777 }
778
779 /* Word and long word swap. */
780 switch (priv->ch[0].format->fourcc) {
781 case V4L2_PIX_FMT_RGB565:
782 case V4L2_PIX_FMT_NV21:
783 case V4L2_PIX_FMT_NV61:
784 case V4L2_PIX_FMT_NV42:
785 tmp = LDDDSR_LS | LDDDSR_WS;
786 break;
787 case V4L2_PIX_FMT_BGR24:
788 case V4L2_PIX_FMT_NV12:
789 case V4L2_PIX_FMT_NV16:
790 case V4L2_PIX_FMT_NV24:
791 tmp = LDDDSR_LS | LDDDSR_WS | LDDDSR_BS;
792 break;
793 case V4L2_PIX_FMT_BGR32:
794 default:
795 tmp = LDDDSR_LS;
796 break;
797 }
798 lcdc_write(priv, _LDDDSR, tmp);
799
800 /* Enable the display output. */
801 lcdc_write(priv, _LDCNT1R, LDCNT1R_DE);
802 sh_mobile_lcdc_start_stop(priv, 1);
803 priv->started = 1;
804 }
805
806 static int sh_mobile_lcdc_start(struct sh_mobile_lcdc_priv *priv)
807 {
808 struct sh_mobile_meram_info *mdev = priv->meram_dev;
809 struct sh_mobile_lcdc_chan *ch;
810 unsigned long tmp;
811 int ret;
812 int k;
813
814 /* enable clocks before accessing the hardware */
815 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
816 if (priv->ch[k].enabled)
817 sh_mobile_lcdc_clk_on(priv);
818 }
819
820 /* reset */
821 lcdc_write(priv, _LDCNT2R, lcdc_read(priv, _LDCNT2R) | LDCNT2R_BR);
822 lcdc_wait_bit(priv, _LDCNT2R, LDCNT2R_BR, 0);
823
824 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
825 struct sh_mobile_lcdc_panel_cfg *panel;
826
827 ch = &priv->ch[k];
828 if (!ch->enabled)
829 continue;
830
831 panel = &ch->cfg.panel_cfg;
832 if (panel->setup_sys) {
833 ret = panel->setup_sys(ch, &sh_mobile_lcdc_sys_bus_ops);
834 if (ret)
835 return ret;
836 }
837 }
838
839 /* Compute frame buffer base address and pitch for each channel. */
840 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
841 struct sh_mobile_meram_cfg *cfg;
842 int pixelformat;
843 void *meram;
844
845 ch = &priv->ch[k];
846 if (!ch->enabled)
847 continue;
848
849 ch->base_addr_y = ch->dma_handle;
850 ch->base_addr_c = ch->base_addr_y + ch->xres * ch->yres_virtual;
851
852 /* Enable MERAM if possible. */
853 cfg = ch->cfg.meram_cfg;
854 if (mdev == NULL || mdev->ops == NULL || cfg == NULL)
855 continue;
856
857 /* we need to de-init configured ICBs before we can
858 * re-initialize them.
859 */
860 if (ch->meram) {
861 mdev->ops->meram_unregister(mdev, ch->meram);
862 ch->meram = NULL;
863 }
864
865 switch (ch->format->fourcc) {
866 case V4L2_PIX_FMT_NV12:
867 case V4L2_PIX_FMT_NV21:
868 case V4L2_PIX_FMT_NV16:
869 case V4L2_PIX_FMT_NV61:
870 pixelformat = SH_MOBILE_MERAM_PF_NV;
871 break;
872 case V4L2_PIX_FMT_NV24:
873 case V4L2_PIX_FMT_NV42:
874 pixelformat = SH_MOBILE_MERAM_PF_NV24;
875 break;
876 case V4L2_PIX_FMT_RGB565:
877 case V4L2_PIX_FMT_BGR24:
878 case V4L2_PIX_FMT_BGR32:
879 default:
880 pixelformat = SH_MOBILE_MERAM_PF_RGB;
881 break;
882 }
883
884 meram = mdev->ops->meram_register(mdev, cfg, ch->pitch,
885 ch->yres, pixelformat,
886 ch->base_addr_y, ch->base_addr_c,
887 &ch->base_addr_y, &ch->base_addr_c,
888 &ch->pitch);
889 if (!IS_ERR(meram))
890 ch->meram = meram;
891 }
892
893 /* Start the LCDC. */
894 __sh_mobile_lcdc_start(priv);
895
896 /* Setup deferred I/O, tell the board code to enable the panels, and
897 * turn backlight on.
898 */
899 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
900 ch = &priv->ch[k];
901 if (!ch->enabled)
902 continue;
903
904 tmp = ch->cfg.sys_bus_cfg.deferred_io_msec;
905 if (ch->ldmt1r_value & LDMT1R_IFM && tmp) {
906 ch->defio.deferred_io = sh_mobile_lcdc_deferred_io;
907 ch->defio.delay = msecs_to_jiffies(tmp);
908 ch->info->fbdefio = &ch->defio;
909 fb_deferred_io_init(ch->info);
910 }
911
912 sh_mobile_lcdc_display_on(ch);
913
914 if (ch->bl) {
915 ch->bl->props.power = FB_BLANK_UNBLANK;
916 backlight_update_status(ch->bl);
917 }
918 }
919
920 return 0;
921 }
922
923 static void sh_mobile_lcdc_stop(struct sh_mobile_lcdc_priv *priv)
924 {
925 struct sh_mobile_lcdc_chan *ch;
926 int k;
927
928 /* clean up deferred io and ask board code to disable panel */
929 for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
930 ch = &priv->ch[k];
931 if (!ch->enabled)
932 continue;
933
934 /* deferred io mode:
935 * flush frame, and wait for frame end interrupt
936 * clean up deferred io and enable clock
937 */
938 if (ch->info && ch->info->fbdefio) {
939 ch->frame_end = 0;
940 schedule_delayed_work(&ch->info->deferred_work, 0);
941 wait_event(ch->frame_end_wait, ch->frame_end);
942 fb_deferred_io_cleanup(ch->info);
943 ch->info->fbdefio = NULL;
944 sh_mobile_lcdc_clk_on(priv);
945 }
946
947 if (ch->bl) {
948 ch->bl->props.power = FB_BLANK_POWERDOWN;
949 backlight_update_status(ch->bl);
950 }
951
952 sh_mobile_lcdc_display_off(ch);
953
954 /* disable the meram */
955 if (ch->meram) {
956 struct sh_mobile_meram_info *mdev;
957 mdev = priv->meram_dev;
958 mdev->ops->meram_unregister(mdev, ch->meram);
959 ch->meram = 0;
960 }
961
962 }
963
964 /* stop the lcdc */
965 if (priv->started) {
966 sh_mobile_lcdc_start_stop(priv, 0);
967 priv->started = 0;
968 }
969
970 /* stop clocks */
971 for (k = 0; k < ARRAY_SIZE(priv->ch); k++)
972 if (priv->ch[k].enabled)
973 sh_mobile_lcdc_clk_off(priv);
974 }
975
976 /* -----------------------------------------------------------------------------
977 * Frame buffer operations
978 */
979
980 static int sh_mobile_lcdc_setcolreg(u_int regno,
981 u_int red, u_int green, u_int blue,
982 u_int transp, struct fb_info *info)
983 {
984 u32 *palette = info->pseudo_palette;
985
986 if (regno >= PALETTE_NR)
987 return -EINVAL;
988
989 /* only FB_VISUAL_TRUECOLOR supported */
990
991 red >>= 16 - info->var.red.length;
992 green >>= 16 - info->var.green.length;
993 blue >>= 16 - info->var.blue.length;
994 transp >>= 16 - info->var.transp.length;
995
996 palette[regno] = (red << info->var.red.offset) |
997 (green << info->var.green.offset) |
998 (blue << info->var.blue.offset) |
999 (transp << info->var.transp.offset);
1000
1001 return 0;
1002 }
1003
1004 static struct fb_fix_screeninfo sh_mobile_lcdc_fix = {
1005 .id = "SH Mobile LCDC",
1006 .type = FB_TYPE_PACKED_PIXELS,
1007 .visual = FB_VISUAL_TRUECOLOR,
1008 .accel = FB_ACCEL_NONE,
1009 .xpanstep = 0,
1010 .ypanstep = 1,
1011 .ywrapstep = 0,
1012 .capabilities = FB_CAP_FOURCC,
1013 };
1014
1015 static void sh_mobile_lcdc_fillrect(struct fb_info *info,
1016 const struct fb_fillrect *rect)
1017 {
1018 sys_fillrect(info, rect);
1019 sh_mobile_lcdc_deferred_io_touch(info);
1020 }
1021
1022 static void sh_mobile_lcdc_copyarea(struct fb_info *info,
1023 const struct fb_copyarea *area)
1024 {
1025 sys_copyarea(info, area);
1026 sh_mobile_lcdc_deferred_io_touch(info);
1027 }
1028
1029 static void sh_mobile_lcdc_imageblit(struct fb_info *info,
1030 const struct fb_image *image)
1031 {
1032 sys_imageblit(info, image);
1033 sh_mobile_lcdc_deferred_io_touch(info);
1034 }
1035
1036 static int sh_mobile_fb_pan_display(struct fb_var_screeninfo *var,
1037 struct fb_info *info)
1038 {
1039 struct sh_mobile_lcdc_chan *ch = info->par;
1040 struct sh_mobile_lcdc_priv *priv = ch->lcdc;
1041 unsigned long ldrcntr;
1042 unsigned long new_pan_offset;
1043 unsigned long base_addr_y, base_addr_c;
1044 unsigned long c_offset;
1045
1046 if (!ch->format->yuv)
1047 new_pan_offset = var->yoffset * ch->pitch
1048 + var->xoffset * (ch->format->bpp / 8);
1049 else
1050 new_pan_offset = var->yoffset * ch->pitch + var->xoffset;
1051
1052 if (new_pan_offset == ch->pan_offset)
1053 return 0; /* No change, do nothing */
1054
1055 ldrcntr = lcdc_read(priv, _LDRCNTR);
1056
1057 /* Set the source address for the next refresh */
1058 base_addr_y = ch->dma_handle + new_pan_offset;
1059 if (ch->format->yuv) {
1060 /* Set y offset */
1061 c_offset = var->yoffset * ch->pitch
1062 * (ch->format->bpp - 8) / 8;
1063 base_addr_c = ch->dma_handle + ch->xres * ch->yres_virtual
1064 + c_offset;
1065 /* Set x offset */
1066 if (ch->format->fourcc == V4L2_PIX_FMT_NV24)
1067 base_addr_c += 2 * var->xoffset;
1068 else
1069 base_addr_c += var->xoffset;
1070 }
1071
1072 if (ch->meram) {
1073 struct sh_mobile_meram_info *mdev;
1074 int ret;
1075
1076 mdev = priv->meram_dev;
1077 ret = mdev->ops->meram_update(mdev, ch->meram,
1078 base_addr_y, base_addr_c,
1079 &base_addr_y, &base_addr_c);
1080 if (ret)
1081 return ret;
1082 }
1083
1084 ch->base_addr_y = base_addr_y;
1085 ch->base_addr_c = base_addr_c;
1086
1087 lcdc_write_chan_mirror(ch, LDSA1R, base_addr_y);
1088 if (ch->format->yuv)
1089 lcdc_write_chan_mirror(ch, LDSA2R, base_addr_c);
1090
1091 if (lcdc_chan_is_sublcd(ch))
1092 lcdc_write(ch->lcdc, _LDRCNTR, ldrcntr ^ LDRCNTR_SRS);
1093 else
1094 lcdc_write(ch->lcdc, _LDRCNTR, ldrcntr ^ LDRCNTR_MRS);
1095
1096 ch->pan_offset = new_pan_offset;
1097
1098 sh_mobile_lcdc_deferred_io_touch(info);
1099
1100 return 0;
1101 }
1102
1103 static int sh_mobile_ioctl(struct fb_info *info, unsigned int cmd,
1104 unsigned long arg)
1105 {
1106 int retval;
1107
1108 switch (cmd) {
1109 case FBIO_WAITFORVSYNC:
1110 retval = sh_mobile_wait_for_vsync(info->par);
1111 break;
1112
1113 default:
1114 retval = -ENOIOCTLCMD;
1115 break;
1116 }
1117 return retval;
1118 }
1119
1120 static void sh_mobile_fb_reconfig(struct fb_info *info)
1121 {
1122 struct sh_mobile_lcdc_chan *ch = info->par;
1123 struct fb_var_screeninfo var;
1124 struct fb_videomode mode;
1125 struct fb_event event;
1126 int evnt = FB_EVENT_MODE_CHANGE_ALL;
1127
1128 if (ch->use_count > 1 || (ch->use_count == 1 && !info->fbcon_par))
1129 /* More framebuffer users are active */
1130 return;
1131
1132 fb_var_to_videomode(&mode, &info->var);
1133
1134 if (fb_mode_is_equal(&ch->display.mode, &mode))
1135 return;
1136
1137 /* Display has been re-plugged, framebuffer is free now, reconfigure */
1138 var = info->var;
1139 fb_videomode_to_var(&var, &ch->display.mode);
1140 var.width = ch->display.width;
1141 var.height = ch->display.height;
1142 var.activate = FB_ACTIVATE_NOW;
1143
1144 if (fb_set_var(info, &var) < 0)
1145 /* Couldn't reconfigure, hopefully, can continue as before */
1146 return;
1147
1148 /*
1149 * fb_set_var() calls the notifier change internally, only if
1150 * FBINFO_MISC_USEREVENT flag is set. Since we do not want to fake a
1151 * user event, we have to call the chain ourselves.
1152 */
1153 event.info = info;
1154 event.data = &ch->display.mode;
1155 fb_notifier_call_chain(evnt, &event);
1156 }
1157
1158 /*
1159 * Locking: both .fb_release() and .fb_open() are called with info->lock held if
1160 * user == 1, or with console sem held, if user == 0.
1161 */
1162 static int sh_mobile_release(struct fb_info *info, int user)
1163 {
1164 struct sh_mobile_lcdc_chan *ch = info->par;
1165
1166 mutex_lock(&ch->open_lock);
1167 dev_dbg(info->dev, "%s(): %d users\n", __func__, ch->use_count);
1168
1169 ch->use_count--;
1170
1171 /* Nothing to reconfigure, when called from fbcon */
1172 if (user) {
1173 console_lock();
1174 sh_mobile_fb_reconfig(info);
1175 console_unlock();
1176 }
1177
1178 mutex_unlock(&ch->open_lock);
1179
1180 return 0;
1181 }
1182
1183 static int sh_mobile_open(struct fb_info *info, int user)
1184 {
1185 struct sh_mobile_lcdc_chan *ch = info->par;
1186
1187 mutex_lock(&ch->open_lock);
1188 ch->use_count++;
1189
1190 dev_dbg(info->dev, "%s(): %d users\n", __func__, ch->use_count);
1191 mutex_unlock(&ch->open_lock);
1192
1193 return 0;
1194 }
1195
1196 static int sh_mobile_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
1197 {
1198 struct sh_mobile_lcdc_chan *ch = info->par;
1199 struct sh_mobile_lcdc_priv *p = ch->lcdc;
1200 unsigned int best_dist = (unsigned int)-1;
1201 unsigned int best_xres = 0;
1202 unsigned int best_yres = 0;
1203 unsigned int i;
1204
1205 if (var->xres > MAX_XRES || var->yres > MAX_YRES)
1206 return -EINVAL;
1207
1208 /* If board code provides us with a list of available modes, make sure
1209 * we use one of them. Find the mode closest to the requested one. The
1210 * distance between two modes is defined as the size of the
1211 * non-overlapping parts of the two rectangles.
1212 */
1213 for (i = 0; i < ch->cfg.num_modes; ++i) {
1214 const struct fb_videomode *mode = &ch->cfg.lcd_modes[i];
1215 unsigned int dist;
1216
1217 /* We can only round up. */
1218 if (var->xres > mode->xres || var->yres > mode->yres)
1219 continue;
1220
1221 dist = var->xres * var->yres + mode->xres * mode->yres
1222 - 2 * min(var->xres, mode->xres)
1223 * min(var->yres, mode->yres);
1224
1225 if (dist < best_dist) {
1226 best_xres = mode->xres;
1227 best_yres = mode->yres;
1228 best_dist = dist;
1229 }
1230 }
1231
1232 /* If no available mode can be used, return an error. */
1233 if (ch->cfg.num_modes != 0) {
1234 if (best_dist == (unsigned int)-1)
1235 return -EINVAL;
1236
1237 var->xres = best_xres;
1238 var->yres = best_yres;
1239 }
1240
1241 /* Make sure the virtual resolution is at least as big as the visible
1242 * resolution.
1243 */
1244 if (var->xres_virtual < var->xres)
1245 var->xres_virtual = var->xres;
1246 if (var->yres_virtual < var->yres)
1247 var->yres_virtual = var->yres;
1248
1249 if (sh_mobile_format_is_fourcc(var)) {
1250 const struct sh_mobile_lcdc_format_info *format;
1251
1252 format = sh_mobile_format_info(var->grayscale);
1253 if (format == NULL)
1254 return -EINVAL;
1255 var->bits_per_pixel = format->bpp;
1256
1257 /* Default to RGB and JPEG color-spaces for RGB and YUV formats
1258 * respectively.
1259 */
1260 if (!format->yuv)
1261 var->colorspace = V4L2_COLORSPACE_SRGB;
1262 else if (var->colorspace != V4L2_COLORSPACE_REC709)
1263 var->colorspace = V4L2_COLORSPACE_JPEG;
1264 } else {
1265 if (var->bits_per_pixel <= 16) { /* RGB 565 */
1266 var->bits_per_pixel = 16;
1267 var->red.offset = 11;
1268 var->red.length = 5;
1269 var->green.offset = 5;
1270 var->green.length = 6;
1271 var->blue.offset = 0;
1272 var->blue.length = 5;
1273 var->transp.offset = 0;
1274 var->transp.length = 0;
1275 } else if (var->bits_per_pixel <= 24) { /* RGB 888 */
1276 var->bits_per_pixel = 24;
1277 var->red.offset = 16;
1278 var->red.length = 8;
1279 var->green.offset = 8;
1280 var->green.length = 8;
1281 var->blue.offset = 0;
1282 var->blue.length = 8;
1283 var->transp.offset = 0;
1284 var->transp.length = 0;
1285 } else if (var->bits_per_pixel <= 32) { /* RGBA 888 */
1286 var->bits_per_pixel = 32;
1287 var->red.offset = 16;
1288 var->red.length = 8;
1289 var->green.offset = 8;
1290 var->green.length = 8;
1291 var->blue.offset = 0;
1292 var->blue.length = 8;
1293 var->transp.offset = 24;
1294 var->transp.length = 8;
1295 } else
1296 return -EINVAL;
1297
1298 var->red.msb_right = 0;
1299 var->green.msb_right = 0;
1300 var->blue.msb_right = 0;
1301 var->transp.msb_right = 0;
1302 }
1303
1304 /* Make sure we don't exceed our allocated memory. */
1305 if (var->xres_virtual * var->yres_virtual * var->bits_per_pixel / 8 >
1306 info->fix.smem_len)
1307 return -EINVAL;
1308
1309 /* only accept the forced_fourcc for dual channel configurations */
1310 if (p->forced_fourcc &&
1311 p->forced_fourcc != sh_mobile_format_fourcc(var))
1312 return -EINVAL;
1313
1314 return 0;
1315 }
1316
1317 static int sh_mobile_set_par(struct fb_info *info)
1318 {
1319 struct sh_mobile_lcdc_chan *ch = info->par;
1320 int ret;
1321
1322 sh_mobile_lcdc_stop(ch->lcdc);
1323
1324 ch->format = sh_mobile_format_info(sh_mobile_format_fourcc(&info->var));
1325 ch->colorspace = info->var.colorspace;
1326
1327 ch->xres = info->var.xres;
1328 ch->xres_virtual = info->var.xres_virtual;
1329 ch->yres = info->var.yres;
1330 ch->yres_virtual = info->var.yres_virtual;
1331
1332 if (ch->format->yuv)
1333 ch->pitch = info->var.xres;
1334 else
1335 ch->pitch = info->var.xres * ch->format->bpp / 8;
1336
1337 ret = sh_mobile_lcdc_start(ch->lcdc);
1338 if (ret < 0)
1339 dev_err(info->dev, "%s: unable to restart LCDC\n", __func__);
1340
1341 info->fix.line_length = ch->pitch;
1342
1343 if (sh_mobile_format_is_fourcc(&info->var)) {
1344 info->fix.type = FB_TYPE_FOURCC;
1345 info->fix.visual = FB_VISUAL_FOURCC;
1346 } else {
1347 info->fix.type = FB_TYPE_PACKED_PIXELS;
1348 info->fix.visual = FB_VISUAL_TRUECOLOR;
1349 }
1350
1351 return ret;
1352 }
1353
1354 /*
1355 * Screen blanking. Behavior is as follows:
1356 * FB_BLANK_UNBLANK: screen unblanked, clocks enabled
1357 * FB_BLANK_NORMAL: screen blanked, clocks enabled
1358 * FB_BLANK_VSYNC,
1359 * FB_BLANK_HSYNC,
1360 * FB_BLANK_POWEROFF: screen blanked, clocks disabled
1361 */
1362 static int sh_mobile_lcdc_blank(int blank, struct fb_info *info)
1363 {
1364 struct sh_mobile_lcdc_chan *ch = info->par;
1365 struct sh_mobile_lcdc_priv *p = ch->lcdc;
1366
1367 /* blank the screen? */
1368 if (blank > FB_BLANK_UNBLANK && ch->blank_status == FB_BLANK_UNBLANK) {
1369 struct fb_fillrect rect = {
1370 .width = ch->xres,
1371 .height = ch->yres,
1372 };
1373 sh_mobile_lcdc_fillrect(info, &rect);
1374 }
1375 /* turn clocks on? */
1376 if (blank <= FB_BLANK_NORMAL && ch->blank_status > FB_BLANK_NORMAL) {
1377 sh_mobile_lcdc_clk_on(p);
1378 }
1379 /* turn clocks off? */
1380 if (blank > FB_BLANK_NORMAL && ch->blank_status <= FB_BLANK_NORMAL) {
1381 /* make sure the screen is updated with the black fill before
1382 * switching the clocks off. one vsync is not enough since
1383 * blanking may occur in the middle of a refresh. deferred io
1384 * mode will reenable the clocks and update the screen in time,
1385 * so it does not need this. */
1386 if (!info->fbdefio) {
1387 sh_mobile_wait_for_vsync(ch);
1388 sh_mobile_wait_for_vsync(ch);
1389 }
1390 sh_mobile_lcdc_clk_off(p);
1391 }
1392
1393 ch->blank_status = blank;
1394 return 0;
1395 }
1396
1397 static struct fb_ops sh_mobile_lcdc_ops = {
1398 .owner = THIS_MODULE,
1399 .fb_setcolreg = sh_mobile_lcdc_setcolreg,
1400 .fb_read = fb_sys_read,
1401 .fb_write = fb_sys_write,
1402 .fb_fillrect = sh_mobile_lcdc_fillrect,
1403 .fb_copyarea = sh_mobile_lcdc_copyarea,
1404 .fb_imageblit = sh_mobile_lcdc_imageblit,
1405 .fb_blank = sh_mobile_lcdc_blank,
1406 .fb_pan_display = sh_mobile_fb_pan_display,
1407 .fb_ioctl = sh_mobile_ioctl,
1408 .fb_open = sh_mobile_open,
1409 .fb_release = sh_mobile_release,
1410 .fb_check_var = sh_mobile_check_var,
1411 .fb_set_par = sh_mobile_set_par,
1412 };
1413
1414 static void
1415 sh_mobile_lcdc_channel_fb_unregister(struct sh_mobile_lcdc_chan *ch)
1416 {
1417 if (ch->info && ch->info->dev)
1418 unregister_framebuffer(ch->info);
1419 }
1420
1421 static int __devinit
1422 sh_mobile_lcdc_channel_fb_register(struct sh_mobile_lcdc_chan *ch)
1423 {
1424 struct fb_info *info = ch->info;
1425 int ret;
1426
1427 if (info->fbdefio) {
1428 ch->sglist = vmalloc(sizeof(struct scatterlist) *
1429 ch->fb_size >> PAGE_SHIFT);
1430 if (!ch->sglist) {
1431 dev_err(ch->lcdc->dev, "cannot allocate sglist\n");
1432 return -ENOMEM;
1433 }
1434 }
1435
1436 info->bl_dev = ch->bl;
1437
1438 ret = register_framebuffer(info);
1439 if (ret < 0)
1440 return ret;
1441
1442 dev_info(ch->lcdc->dev, "registered %s/%s as %dx%d %dbpp.\n",
1443 dev_name(ch->lcdc->dev), (ch->cfg.chan == LCDC_CHAN_MAINLCD) ?
1444 "mainlcd" : "sublcd", info->var.xres, info->var.yres,
1445 info->var.bits_per_pixel);
1446
1447 /* deferred io mode: disable clock to save power */
1448 if (info->fbdefio || info->state == FBINFO_STATE_SUSPENDED)
1449 sh_mobile_lcdc_clk_off(ch->lcdc);
1450
1451 return ret;
1452 }
1453
1454 static void
1455 sh_mobile_lcdc_channel_fb_cleanup(struct sh_mobile_lcdc_chan *ch)
1456 {
1457 struct fb_info *info = ch->info;
1458
1459 if (!info || !info->device)
1460 return;
1461
1462 if (ch->sglist)
1463 vfree(ch->sglist);
1464
1465 fb_dealloc_cmap(&info->cmap);
1466 framebuffer_release(info);
1467 }
1468
1469 static int __devinit
1470 sh_mobile_lcdc_channel_fb_init(struct sh_mobile_lcdc_chan *ch,
1471 const struct fb_videomode *mode,
1472 unsigned int num_modes)
1473 {
1474 struct sh_mobile_lcdc_priv *priv = ch->lcdc;
1475 struct fb_var_screeninfo *var;
1476 struct fb_info *info;
1477 int ret;
1478
1479 /* Allocate and initialize the frame buffer device. Create the modes
1480 * list and allocate the color map.
1481 */
1482 info = framebuffer_alloc(0, priv->dev);
1483 if (info == NULL) {
1484 dev_err(priv->dev, "unable to allocate fb_info\n");
1485 return -ENOMEM;
1486 }
1487
1488 ch->info = info;
1489
1490 info->flags = FBINFO_FLAG_DEFAULT;
1491 info->fbops = &sh_mobile_lcdc_ops;
1492 info->device = priv->dev;
1493 info->screen_base = ch->fb_mem;
1494 info->pseudo_palette = &ch->pseudo_palette;
1495 info->par = ch;
1496
1497 fb_videomode_to_modelist(mode, num_modes, &info->modelist);
1498
1499 ret = fb_alloc_cmap(&info->cmap, PALETTE_NR, 0);
1500 if (ret < 0) {
1501 dev_err(priv->dev, "unable to allocate cmap\n");
1502 return ret;
1503 }
1504
1505 /* Initialize fixed screen information. Restrict pan to 2 lines steps
1506 * for NV12 and NV21.
1507 */
1508 info->fix = sh_mobile_lcdc_fix;
1509 info->fix.smem_start = ch->dma_handle;
1510 info->fix.smem_len = ch->fb_size;
1511 info->fix.line_length = ch->pitch;
1512
1513 if (ch->format->yuv)
1514 info->fix.visual = FB_VISUAL_FOURCC;
1515 else
1516 info->fix.visual = FB_VISUAL_TRUECOLOR;
1517
1518 if (ch->format->fourcc == V4L2_PIX_FMT_NV12 ||
1519 ch->format->fourcc == V4L2_PIX_FMT_NV21)
1520 info->fix.ypanstep = 2;
1521
1522 /* Initialize variable screen information using the first mode as
1523 * default. The default Y virtual resolution is twice the panel size to
1524 * allow for double-buffering.
1525 */
1526 var = &info->var;
1527 fb_videomode_to_var(var, mode);
1528 var->width = ch->cfg.panel_cfg.width;
1529 var->height = ch->cfg.panel_cfg.height;
1530 var->yres_virtual = var->yres * 2;
1531 var->activate = FB_ACTIVATE_NOW;
1532
1533 /* Use the legacy API by default for RGB formats, and the FOURCC API
1534 * for YUV formats.
1535 */
1536 if (!ch->format->yuv)
1537 var->bits_per_pixel = ch->format->bpp;
1538 else
1539 var->grayscale = ch->format->fourcc;
1540
1541 ret = sh_mobile_check_var(var, info);
1542 if (ret)
1543 return ret;
1544
1545 return 0;
1546 }
1547
1548 /* -----------------------------------------------------------------------------
1549 * Backlight
1550 */
1551
1552 static int sh_mobile_lcdc_update_bl(struct backlight_device *bdev)
1553 {
1554 struct sh_mobile_lcdc_chan *ch = bl_get_data(bdev);
1555 int brightness = bdev->props.brightness;
1556
1557 if (bdev->props.power != FB_BLANK_UNBLANK ||
1558 bdev->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK))
1559 brightness = 0;
1560
1561 return ch->cfg.bl_info.set_brightness(brightness);
1562 }
1563
1564 static int sh_mobile_lcdc_get_brightness(struct backlight_device *bdev)
1565 {
1566 struct sh_mobile_lcdc_chan *ch = bl_get_data(bdev);
1567
1568 return ch->cfg.bl_info.get_brightness();
1569 }
1570
1571 static int sh_mobile_lcdc_check_fb(struct backlight_device *bdev,
1572 struct fb_info *info)
1573 {
1574 return (info->bl_dev == bdev);
1575 }
1576
1577 static struct backlight_ops sh_mobile_lcdc_bl_ops = {
1578 .options = BL_CORE_SUSPENDRESUME,
1579 .update_status = sh_mobile_lcdc_update_bl,
1580 .get_brightness = sh_mobile_lcdc_get_brightness,
1581 .check_fb = sh_mobile_lcdc_check_fb,
1582 };
1583
1584 static struct backlight_device *sh_mobile_lcdc_bl_probe(struct device *parent,
1585 struct sh_mobile_lcdc_chan *ch)
1586 {
1587 struct backlight_device *bl;
1588
1589 bl = backlight_device_register(ch->cfg.bl_info.name, parent, ch,
1590 &sh_mobile_lcdc_bl_ops, NULL);
1591 if (IS_ERR(bl)) {
1592 dev_err(parent, "unable to register backlight device: %ld\n",
1593 PTR_ERR(bl));
1594 return NULL;
1595 }
1596
1597 bl->props.max_brightness = ch->cfg.bl_info.max_brightness;
1598 bl->props.brightness = bl->props.max_brightness;
1599 backlight_update_status(bl);
1600
1601 return bl;
1602 }
1603
1604 static void sh_mobile_lcdc_bl_remove(struct backlight_device *bdev)
1605 {
1606 backlight_device_unregister(bdev);
1607 }
1608
1609 /* -----------------------------------------------------------------------------
1610 * Power management
1611 */
1612
1613 static int sh_mobile_lcdc_suspend(struct device *dev)
1614 {
1615 struct platform_device *pdev = to_platform_device(dev);
1616
1617 sh_mobile_lcdc_stop(platform_get_drvdata(pdev));
1618 return 0;
1619 }
1620
1621 static int sh_mobile_lcdc_resume(struct device *dev)
1622 {
1623 struct platform_device *pdev = to_platform_device(dev);
1624
1625 return sh_mobile_lcdc_start(platform_get_drvdata(pdev));
1626 }
1627
1628 static int sh_mobile_lcdc_runtime_suspend(struct device *dev)
1629 {
1630 struct platform_device *pdev = to_platform_device(dev);
1631 struct sh_mobile_lcdc_priv *priv = platform_get_drvdata(pdev);
1632
1633 /* turn off LCDC hardware */
1634 lcdc_write(priv, _LDCNT1R, 0);
1635
1636 return 0;
1637 }
1638
1639 static int sh_mobile_lcdc_runtime_resume(struct device *dev)
1640 {
1641 struct platform_device *pdev = to_platform_device(dev);
1642 struct sh_mobile_lcdc_priv *priv = platform_get_drvdata(pdev);
1643
1644 __sh_mobile_lcdc_start(priv);
1645
1646 return 0;
1647 }
1648
1649 static const struct dev_pm_ops sh_mobile_lcdc_dev_pm_ops = {
1650 .suspend = sh_mobile_lcdc_suspend,
1651 .resume = sh_mobile_lcdc_resume,
1652 .runtime_suspend = sh_mobile_lcdc_runtime_suspend,
1653 .runtime_resume = sh_mobile_lcdc_runtime_resume,
1654 };
1655
1656 /* -----------------------------------------------------------------------------
1657 * Framebuffer notifier
1658 */
1659
1660 /* locking: called with info->lock held */
1661 static int sh_mobile_lcdc_notify(struct notifier_block *nb,
1662 unsigned long action, void *data)
1663 {
1664 struct fb_event *event = data;
1665 struct fb_info *info = event->info;
1666 struct sh_mobile_lcdc_chan *ch = info->par;
1667
1668 if (&ch->lcdc->notifier != nb)
1669 return NOTIFY_DONE;
1670
1671 dev_dbg(info->dev, "%s(): action = %lu, data = %p\n",
1672 __func__, action, event->data);
1673
1674 switch(action) {
1675 case FB_EVENT_SUSPEND:
1676 sh_mobile_lcdc_display_off(ch);
1677 sh_mobile_lcdc_stop(ch->lcdc);
1678 break;
1679 case FB_EVENT_RESUME:
1680 mutex_lock(&ch->open_lock);
1681 sh_mobile_fb_reconfig(info);
1682 mutex_unlock(&ch->open_lock);
1683
1684 sh_mobile_lcdc_display_on(ch);
1685 sh_mobile_lcdc_start(ch->lcdc);
1686 }
1687
1688 return NOTIFY_OK;
1689 }
1690
1691 /* -----------------------------------------------------------------------------
1692 * Probe/remove and driver init/exit
1693 */
1694
1695 static const struct fb_videomode default_720p __devinitconst = {
1696 .name = "HDMI 720p",
1697 .xres = 1280,
1698 .yres = 720,
1699
1700 .left_margin = 220,
1701 .right_margin = 110,
1702 .hsync_len = 40,
1703
1704 .upper_margin = 20,
1705 .lower_margin = 5,
1706 .vsync_len = 5,
1707
1708 .pixclock = 13468,
1709 .refresh = 60,
1710 .sync = FB_SYNC_VERT_HIGH_ACT | FB_SYNC_HOR_HIGH_ACT,
1711 };
1712
1713 static int sh_mobile_lcdc_remove(struct platform_device *pdev)
1714 {
1715 struct sh_mobile_lcdc_priv *priv = platform_get_drvdata(pdev);
1716 int i;
1717
1718 fb_unregister_client(&priv->notifier);
1719
1720 for (i = 0; i < ARRAY_SIZE(priv->ch); i++)
1721 sh_mobile_lcdc_channel_fb_unregister(&priv->ch[i]);
1722
1723 sh_mobile_lcdc_stop(priv);
1724
1725 for (i = 0; i < ARRAY_SIZE(priv->ch); i++) {
1726 struct sh_mobile_lcdc_chan *ch = &priv->ch[i];
1727
1728 if (ch->tx_dev) {
1729 ch->tx_dev->lcdc = NULL;
1730 module_put(ch->cfg.tx_dev->dev.driver->owner);
1731 }
1732
1733 sh_mobile_lcdc_channel_fb_cleanup(ch);
1734
1735 if (ch->fb_mem)
1736 dma_free_coherent(&pdev->dev, ch->fb_size,
1737 ch->fb_mem, ch->dma_handle);
1738 }
1739
1740 for (i = 0; i < ARRAY_SIZE(priv->ch); i++) {
1741 if (priv->ch[i].bl)
1742 sh_mobile_lcdc_bl_remove(priv->ch[i].bl);
1743 }
1744
1745 if (priv->dot_clk) {
1746 pm_runtime_disable(&pdev->dev);
1747 clk_put(priv->dot_clk);
1748 }
1749
1750 if (priv->base)
1751 iounmap(priv->base);
1752
1753 if (priv->irq)
1754 free_irq(priv->irq, priv);
1755 kfree(priv);
1756 return 0;
1757 }
1758
1759 static int __devinit sh_mobile_lcdc_check_interface(struct sh_mobile_lcdc_chan *ch)
1760 {
1761 int interface_type = ch->cfg.interface_type;
1762
1763 switch (interface_type) {
1764 case RGB8:
1765 case RGB9:
1766 case RGB12A:
1767 case RGB12B:
1768 case RGB16:
1769 case RGB18:
1770 case RGB24:
1771 case SYS8A:
1772 case SYS8B:
1773 case SYS8C:
1774 case SYS8D:
1775 case SYS9:
1776 case SYS12:
1777 case SYS16A:
1778 case SYS16B:
1779 case SYS16C:
1780 case SYS18:
1781 case SYS24:
1782 break;
1783 default:
1784 return -EINVAL;
1785 }
1786
1787 /* SUBLCD only supports SYS interface */
1788 if (lcdc_chan_is_sublcd(ch)) {
1789 if (!(interface_type & LDMT1R_IFM))
1790 return -EINVAL;
1791
1792 interface_type &= ~LDMT1R_IFM;
1793 }
1794
1795 ch->ldmt1r_value = interface_type;
1796 return 0;
1797 }
1798
1799 static int __devinit
1800 sh_mobile_lcdc_channel_init(struct sh_mobile_lcdc_priv *priv,
1801 struct sh_mobile_lcdc_chan *ch)
1802 {
1803 const struct sh_mobile_lcdc_format_info *format;
1804 struct sh_mobile_lcdc_chan_cfg *cfg = &ch->cfg;
1805 const struct fb_videomode *max_mode;
1806 const struct fb_videomode *mode;
1807 unsigned int num_modes;
1808 unsigned int max_size;
1809 unsigned int i;
1810
1811 mutex_init(&ch->open_lock);
1812 ch->notify = sh_mobile_lcdc_display_notify;
1813
1814 /* Validate the format. */
1815 format = sh_mobile_format_info(cfg->fourcc);
1816 if (format == NULL) {
1817 dev_err(priv->dev, "Invalid FOURCC %08x.\n", cfg->fourcc);
1818 return -EINVAL;
1819 }
1820
1821 /* Iterate through the modes to validate them and find the highest
1822 * resolution.
1823 */
1824 max_mode = NULL;
1825 max_size = 0;
1826
1827 for (i = 0, mode = cfg->lcd_modes; i < cfg->num_modes; i++, mode++) {
1828 unsigned int size = mode->yres * mode->xres;
1829
1830 /* NV12/NV21 buffers must have even number of lines */
1831 if ((cfg->fourcc == V4L2_PIX_FMT_NV12 ||
1832 cfg->fourcc == V4L2_PIX_FMT_NV21) && (mode->yres & 0x1)) {
1833 dev_err(priv->dev, "yres must be multiple of 2 for "
1834 "YCbCr420 mode.\n");
1835 return -EINVAL;
1836 }
1837
1838 if (size > max_size) {
1839 max_mode = mode;
1840 max_size = size;
1841 }
1842 }
1843
1844 if (!max_size)
1845 max_size = MAX_XRES * MAX_YRES;
1846 else
1847 dev_dbg(priv->dev, "Found largest videomode %ux%u\n",
1848 max_mode->xres, max_mode->yres);
1849
1850 if (cfg->lcd_modes == NULL) {
1851 mode = &default_720p;
1852 num_modes = 1;
1853 } else {
1854 mode = cfg->lcd_modes;
1855 num_modes = cfg->num_modes;
1856 }
1857
1858 /* Use the first mode as default. */
1859 ch->format = format;
1860 ch->xres = mode->xres;
1861 ch->xres_virtual = mode->xres;
1862 ch->yres = mode->yres;
1863 ch->yres_virtual = mode->yres * 2;
1864
1865 if (!format->yuv) {
1866 ch->colorspace = V4L2_COLORSPACE_SRGB;
1867 ch->pitch = ch->xres * format->bpp / 8;
1868 } else {
1869 ch->colorspace = V4L2_COLORSPACE_REC709;
1870 ch->pitch = ch->xres;
1871 }
1872
1873 ch->display.width = cfg->panel_cfg.width;
1874 ch->display.height = cfg->panel_cfg.height;
1875 ch->display.mode = *mode;
1876
1877 /* Allocate frame buffer memory. */
1878 ch->fb_size = max_size * format->bpp / 8 * 2;
1879 ch->fb_mem = dma_alloc_coherent(priv->dev, ch->fb_size, &ch->dma_handle,
1880 GFP_KERNEL);
1881 if (ch->fb_mem == NULL) {
1882 dev_err(priv->dev, "unable to allocate buffer\n");
1883 return -ENOMEM;
1884 }
1885
1886 /* Initialize the transmitter device if present. */
1887 if (cfg->tx_dev) {
1888 if (!cfg->tx_dev->dev.driver ||
1889 !try_module_get(cfg->tx_dev->dev.driver->owner)) {
1890 dev_warn(priv->dev,
1891 "unable to get transmitter device\n");
1892 return -EINVAL;
1893 }
1894 ch->tx_dev = platform_get_drvdata(cfg->tx_dev);
1895 ch->tx_dev->lcdc = ch;
1896 ch->tx_dev->def_mode = *mode;
1897 }
1898
1899 return sh_mobile_lcdc_channel_fb_init(ch, mode, num_modes);
1900 }
1901
1902 static int __devinit sh_mobile_lcdc_probe(struct platform_device *pdev)
1903 {
1904 struct sh_mobile_lcdc_info *pdata = pdev->dev.platform_data;
1905 struct sh_mobile_lcdc_priv *priv;
1906 struct resource *res;
1907 int num_channels;
1908 int error;
1909 int i;
1910
1911 if (!pdata) {
1912 dev_err(&pdev->dev, "no platform data defined\n");
1913 return -EINVAL;
1914 }
1915
1916 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1917 i = platform_get_irq(pdev, 0);
1918 if (!res || i < 0) {
1919 dev_err(&pdev->dev, "cannot get platform resources\n");
1920 return -ENOENT;
1921 }
1922
1923 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1924 if (!priv) {
1925 dev_err(&pdev->dev, "cannot allocate device data\n");
1926 return -ENOMEM;
1927 }
1928
1929 priv->dev = &pdev->dev;
1930 priv->meram_dev = pdata->meram_dev;
1931 platform_set_drvdata(pdev, priv);
1932
1933 error = request_irq(i, sh_mobile_lcdc_irq, 0,
1934 dev_name(&pdev->dev), priv);
1935 if (error) {
1936 dev_err(&pdev->dev, "unable to request irq\n");
1937 goto err1;
1938 }
1939
1940 priv->irq = i;
1941 atomic_set(&priv->hw_usecnt, -1);
1942
1943 for (i = 0, num_channels = 0; i < ARRAY_SIZE(pdata->ch); i++) {
1944 struct sh_mobile_lcdc_chan *ch = priv->ch + num_channels;
1945
1946 ch->lcdc = priv;
1947 memcpy(&ch->cfg, &pdata->ch[i], sizeof(pdata->ch[i]));
1948
1949 error = sh_mobile_lcdc_check_interface(ch);
1950 if (error) {
1951 dev_err(&pdev->dev, "unsupported interface type\n");
1952 goto err1;
1953 }
1954 init_waitqueue_head(&ch->frame_end_wait);
1955 init_completion(&ch->vsync_completion);
1956 ch->pan_offset = 0;
1957
1958 /* probe the backlight is there is one defined */
1959 if (ch->cfg.bl_info.max_brightness)
1960 ch->bl = sh_mobile_lcdc_bl_probe(&pdev->dev, ch);
1961
1962 switch (pdata->ch[i].chan) {
1963 case LCDC_CHAN_MAINLCD:
1964 ch->enabled = LDCNT2R_ME;
1965 ch->reg_offs = lcdc_offs_mainlcd;
1966 num_channels++;
1967 break;
1968 case LCDC_CHAN_SUBLCD:
1969 ch->enabled = LDCNT2R_SE;
1970 ch->reg_offs = lcdc_offs_sublcd;
1971 num_channels++;
1972 break;
1973 }
1974 }
1975
1976 if (!num_channels) {
1977 dev_err(&pdev->dev, "no channels defined\n");
1978 error = -EINVAL;
1979 goto err1;
1980 }
1981
1982 /* for dual channel LCDC (MAIN + SUB) force shared format setting */
1983 if (num_channels == 2)
1984 priv->forced_fourcc = pdata->ch[0].fourcc;
1985
1986 priv->base = ioremap_nocache(res->start, resource_size(res));
1987 if (!priv->base)
1988 goto err1;
1989
1990 error = sh_mobile_lcdc_setup_clocks(priv, pdata->clock_source);
1991 if (error) {
1992 dev_err(&pdev->dev, "unable to setup clocks\n");
1993 goto err1;
1994 }
1995
1996 /* Enable runtime PM. */
1997 pm_runtime_enable(&pdev->dev);
1998
1999 for (i = 0; i < num_channels; i++) {
2000 struct sh_mobile_lcdc_chan *ch = priv->ch + i;
2001
2002 error = sh_mobile_lcdc_channel_init(priv, ch);
2003 if (error)
2004 goto err1;
2005 }
2006
2007 error = sh_mobile_lcdc_start(priv);
2008 if (error) {
2009 dev_err(&pdev->dev, "unable to start hardware\n");
2010 goto err1;
2011 }
2012
2013 for (i = 0; i < num_channels; i++) {
2014 struct sh_mobile_lcdc_chan *ch = priv->ch + i;
2015
2016 error = sh_mobile_lcdc_channel_fb_register(ch);
2017 if (error)
2018 goto err1;
2019 }
2020
2021 /* Failure ignored */
2022 priv->notifier.notifier_call = sh_mobile_lcdc_notify;
2023 fb_register_client(&priv->notifier);
2024
2025 return 0;
2026 err1:
2027 sh_mobile_lcdc_remove(pdev);
2028
2029 return error;
2030 }
2031
2032 static struct platform_driver sh_mobile_lcdc_driver = {
2033 .driver = {
2034 .name = "sh_mobile_lcdc_fb",
2035 .owner = THIS_MODULE,
2036 .pm = &sh_mobile_lcdc_dev_pm_ops,
2037 },
2038 .probe = sh_mobile_lcdc_probe,
2039 .remove = sh_mobile_lcdc_remove,
2040 };
2041
2042 module_platform_driver(sh_mobile_lcdc_driver);
2043
2044 MODULE_DESCRIPTION("SuperH Mobile LCDC Framebuffer driver");
2045 MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");
2046 MODULE_LICENSE("GPL v2");
Linux kernel - Deliverables
This page took 0.173315 seconds and 4 git commands to generate.