Annotation of sys/arch/arm/xscale/pxa2x0_lcd.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: pxa2x0_lcd.c,v 1.22 2007/05/27 16:12:11 matthieu Exp $ */
2: /* $NetBSD: pxa2x0_lcd.c,v 1.8 2003/10/03 07:24:05 bsh Exp $ */
3:
4: /*
5: * Copyright (c) 2002 Genetec Corporation. All rights reserved.
6: * Written by Hiroyuki Bessho for Genetec Corporation.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed for the NetBSD Project by
19: * Genetec Corporation.
20: * 4. The name of Genetec Corporation may not be used to endorse or
21: * promote products derived from this software without specific prior
22: * written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY GENETEC CORPORATION ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
26: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
27: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENETEC CORPORATION
28: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34: * POSSIBILITY OF SUCH DAMAGE.
35: */
36:
37: /*
38: * Support PXA2[15]0's integrated LCD controller.
39: */
40:
41: #include <sys/param.h>
42: #include <sys/systm.h>
43: #include <sys/conf.h>
44: #include <sys/uio.h>
45: #include <sys/malloc.h>
46: #include <sys/kernel.h> /* for cold */
47:
48: #include <uvm/uvm_extern.h>
49:
50: #include <dev/cons.h>
51:
52: #include <dev/wscons/wsconsio.h>
53: #include <dev/wscons/wsdisplayvar.h>
54: #include <dev/rasops/rasops.h>
55:
56: #include <machine/bus.h>
57: #include <machine/cpu.h>
58: #include <arm/cpufunc.h>
59:
60: #include <arm/xscale/pxa2x0var.h>
61: #include <arm/xscale/pxa2x0reg.h>
62: #include <arm/xscale/pxa2x0_lcd.h>
63: #include <arm/xscale/pxa2x0_gpio.h>
64:
65: /*
66: * Console variables. These are necessary since console is setup very early,
67: * before devices get attached.
68: */
69: struct {
70: bus_space_tag_t iot;
71: bus_space_handle_t ioh;
72: bus_dma_tag_t dma_tag;
73: const struct lcd_panel_geometry *geometry;
74: struct pxa2x0_lcd_screen scr;
75: } pxa2x0_lcd_console;
76:
77: int lcdintr(void *);
78: void pxa2x0_lcd_geometry(bus_space_tag_t, bus_space_handle_t,
79: const struct lcd_panel_geometry *);
80: void pxa2x0_lcd_initialize(bus_space_tag_t, bus_space_handle_t,
81: const struct lcd_panel_geometry *, void (*)(u_int, int));
82: int pxa2x0_lcd_new_screen(struct pxa2x0_lcd_softc *,
83: struct pxa2x0_lcd_screen *, int);
84: void pxa2x0_lcd_setup_console(struct pxa2x0_lcd_softc *,
85: const struct pxa2x0_wsscreen_descr *);
86: void pxa2x0_lcd_setup_rasops(struct rasops_info *,
87: struct pxa2x0_wsscreen_descr *,
88: const struct lcd_panel_geometry *);
89: void pxa2x0_lcd_start_dma(bus_space_tag_t, bus_space_handle_t,
90: struct pxa2x0_lcd_screen *);
91: void pxa2x0_lcd_stop_dma(bus_space_tag_t, bus_space_handle_t);
92:
93: /*
94: * Setup display geometry parameters.
95: */
96: void
97: pxa2x0_lcd_geometry(bus_space_tag_t iot, bus_space_handle_t ioh,
98: const struct lcd_panel_geometry *info)
99: {
100: int lines;
101: uint32_t ccr0;
102:
103: ccr0 = LCCR0_IMASK;
104: if (info->panel_info & LCDPANEL_ACTIVE)
105: ccr0 |= LCCR0_PAS; /* active mode */
106: if ((info->panel_info & (LCDPANEL_DUAL | LCDPANEL_ACTIVE))
107: == LCDPANEL_DUAL)
108: ccr0 |= LCCR0_SDS; /* dual panel */
109: if (info->panel_info & LCDPANEL_MONOCHROME)
110: ccr0 |= LCCR0_CMS;
111: /* XXX - Zaurus C3000 */
112: ccr0 |= LCCR0_LDDALT |
113: LCCR0_OUC |
114: LCCR0_CMDIM |
115: LCCR0_RDSTM;
116:
117: bus_space_write_4(iot, ioh, LCDC_LCCR0, ccr0);
118:
119: bus_space_write_4(iot, ioh, LCDC_LCCR1,
120: (info->panel_width - 1)
121: | ((info->hsync_pulse_width - 1) << 10)
122: | ((info->end_line_wait - 1) << 16)
123: | ((info->beg_line_wait - 1) << 24));
124:
125: if (info->panel_info & LCDPANEL_DUAL)
126: lines = info->panel_height / 2 + info->extra_lines;
127: else
128: lines = info->panel_height + info->extra_lines;
129:
130: bus_space_write_4(iot, ioh, LCDC_LCCR2,
131: (lines - 1)
132: | (info->vsync_pulse_width << 10)
133: | (info->end_frame_wait << 16)
134: | (info->beg_frame_wait << 24));
135:
136: bus_space_write_4(iot, ioh, LCDC_LCCR3,
137: (info->pixel_clock_div << 0)
138: | (info->ac_bias << 8)
139: | ((info->panel_info &
140: (LCDPANEL_VSP | LCDPANEL_HSP | LCDPANEL_PCP | LCDPANEL_OEP))
141: << 20)
142: | (4 << 24) /* 16bpp */
143: | ((info->panel_info & LCDPANEL_DPC) ? (1 << 27) : 0)
144: );
145: }
146:
147: /*
148: * Initialize the LCD controller.
149: */
150: void
151: pxa2x0_lcd_initialize(bus_space_tag_t iot, bus_space_handle_t ioh,
152: const struct lcd_panel_geometry *geom, void (*clkman)(u_int, int))
153: {
154: int nldd;
155: u_int32_t lccr0, lscr;
156:
157: /* Check if LCD is enabled before programming, it should not
158: * be enabled while it is being reprogrammed, therefore disable
159: * it first.
160: */
161: lccr0 = bus_space_read_4(iot, ioh, LCDC_LCCR0);
162: if (lccr0 & LCCR0_ENB) {
163: lccr0 |= LCCR0_LDM;
164: bus_space_write_4(iot, ioh, LCDC_LCCR0, lccr0);
165: lccr0 = bus_space_read_4(iot, ioh, LCDC_LCCR0); /* paranoia */
166: lccr0 |= LCCR0_DIS;
167: bus_space_write_4(iot, ioh, LCDC_LCCR0, lccr0);
168: do {
169: lscr = bus_space_read_4(iot, ioh, LCDC_LCSR);
170: } while (!(lscr & LCSR_LDD));
171: }
172:
173: /* enable clock */
174: (*clkman)(CKEN_LCD, 1);
175:
176: bus_space_write_4(iot, ioh, LCDC_LCCR0, LCCR0_IMASK);
177:
178: /*
179: * setup GP[77:58] for LCD
180: */
181: /* Always use [FLP]CLK, ACBIAS */
182: pxa2x0_gpio_set_function(74, GPIO_ALT_FN_2_OUT);
183: pxa2x0_gpio_set_function(75, GPIO_ALT_FN_2_OUT);
184: pxa2x0_gpio_set_function(76, GPIO_ALT_FN_2_OUT);
185: pxa2x0_gpio_set_function(77, GPIO_ALT_FN_2_OUT);
186:
187: if ((geom->panel_info & LCDPANEL_ACTIVE) ||
188: ((geom->panel_info & (LCDPANEL_MONOCHROME|LCDPANEL_DUAL)) ==
189: LCDPANEL_DUAL)) {
190: /* active and color dual panel need L_DD[15:0] */
191: nldd = 16;
192: } else if ((geom->panel_info & LCDPANEL_DUAL) ||
193: !(geom->panel_info & LCDPANEL_MONOCHROME)) {
194: /* dual or color need L_DD[7:0] */
195: nldd = 8;
196: } else {
197: /* Otherwise just L_DD[3:0] */
198: nldd = 4;
199: }
200:
201: while (nldd--)
202: pxa2x0_gpio_set_function(58 + nldd, GPIO_ALT_FN_2_OUT);
203:
204: pxa2x0_lcd_geometry(iot, ioh, geom);
205: }
206:
207: /*
208: * Common driver attachment code.
209: */
210: void
211: pxa2x0_lcd_attach_sub(struct pxa2x0_lcd_softc *sc,
212: struct pxaip_attach_args *pxa, struct pxa2x0_wsscreen_descr *descr,
213: const struct lcd_panel_geometry *geom, int console)
214: {
215: bus_space_tag_t iot;
216: bus_space_handle_t ioh;
217: int error;
218:
219: sc->n_screens = 0;
220: LIST_INIT(&sc->screens);
221:
222: /* map controller registers if not console */
223: if (console != 0) {
224: iot = pxa2x0_lcd_console.iot;
225: ioh = pxa2x0_lcd_console.ioh;
226: } else {
227: iot = pxa->pxa_iot;
228: error = bus_space_map(iot, PXA2X0_LCDC_BASE, PXA2X0_LCDC_SIZE,
229: 0, &ioh);
230: if (error) {
231: printf(": failed to map registers %d", error);
232: return;
233: }
234: }
235:
236: sc->iot = iot;
237: sc->ioh = ioh;
238: sc->dma_tag = &pxa2x0_bus_dma_tag;
239:
240: sc->ih = pxa2x0_intr_establish(17, IPL_BIO, lcdintr, sc,
241: sc->dev.dv_xname);
242: if (sc->ih == NULL)
243: printf("%s: unable to establish interrupt at irq %d",
244: sc->dev.dv_xname, 17);
245:
246: sc->geometry = geom;
247:
248: if (console != 0) {
249: /* complete console attachment */
250: pxa2x0_lcd_setup_console(sc, descr);
251: } else {
252: struct rasops_info dummy;
253:
254: pxa2x0_lcd_initialize(iot, ioh, geom, pxa2x0_clkman_config);
255:
256: /*
257: * Initialize a dummy rasops_info to compute fontsize and
258: * the screen size in chars.
259: */
260: bzero(&dummy, sizeof(dummy));
261: pxa2x0_lcd_setup_rasops(&dummy, descr, geom);
262: }
263: }
264:
265: /*
266: * Interrupt handler.
267: */
268: int
269: lcdintr(void *arg)
270: {
271: struct pxa2x0_lcd_softc *sc = arg;
272: bus_space_tag_t iot = sc->iot;
273: bus_space_handle_t ioh = sc->ioh;
274:
275: static uint32_t status;
276:
277: status = bus_space_read_4(iot, ioh, LCDC_LCSR);
278: /* Clear sticky status bits */
279: bus_space_write_4(iot, ioh, LCDC_LCSR, status);
280:
281: return 1;
282: }
283:
284: /*
285: * Enable DMA to cause the display to be refreshed periodically.
286: * This brings the screen to life...
287: */
288: void
289: pxa2x0_lcd_start_dma(bus_space_tag_t iot, bus_space_handle_t ioh,
290: struct pxa2x0_lcd_screen *scr)
291: {
292: uint32_t tmp;
293: int val, save;
294:
295: save = disable_interrupts(I32_bit);
296:
297: switch (scr->depth) {
298: case 1: val = 0; break;
299: case 2: val = 1; break;
300: case 4: val = 2; break;
301: case 8: val = 3; break;
302: case 16:
303: /* FALLTHROUGH */
304: default:
305: val = 4; break;
306: }
307:
308: tmp = bus_space_read_4(iot, ioh, LCDC_LCCR3);
309: bus_space_write_4(iot, ioh, LCDC_LCCR3,
310: (tmp & ~LCCR3_BPP) | (val << LCCR3_BPP_SHIFT));
311:
312: bus_space_write_4(iot, ioh, LCDC_FDADR0,
313: scr->depth == 16 ? scr->dma_desc_pa :
314: scr->dma_desc_pa + 2 * sizeof (struct lcd_dma_descriptor));
315: bus_space_write_4(iot, ioh, LCDC_FDADR1,
316: scr->dma_desc_pa + 1 * sizeof (struct lcd_dma_descriptor));
317:
318: /* clear status */
319: bus_space_write_4(iot, ioh, LCDC_LCSR, 0);
320:
321: delay(1000); /* ??? */
322:
323: /* Enable LCDC */
324: tmp = bus_space_read_4(iot, ioh, LCDC_LCCR0);
325: /*tmp &= ~LCCR0_SFM;*/
326: bus_space_write_4(iot, ioh, LCDC_LCCR0, tmp | LCCR0_ENB);
327:
328: restore_interrupts(save);
329: }
330:
331: /*
332: * Disable screen refresh.
333: */
334: void
335: pxa2x0_lcd_stop_dma(bus_space_tag_t iot, bus_space_handle_t ioh)
336: {
337:
338: /* Stop LCD DMA after current frame */
339: bus_space_write_4(iot, ioh, LCDC_LCCR0,
340: LCCR0_DIS |
341: bus_space_read_4(iot, ioh, LCDC_LCCR0));
342:
343: /* wait for disabling done.
344: XXX: use interrupt. */
345: while (LCCR0_ENB &
346: bus_space_read_4(iot, ioh, LCDC_LCCR0))
347: ;
348:
349: bus_space_write_4(iot, ioh, LCDC_LCCR0,
350: ~LCCR0_DIS &
351: bus_space_read_4(iot, ioh, LCDC_LCCR0));
352: }
353:
354: #define _rgb(r,g,b) (((r)<<11) | ((g)<<5) | b)
355: #define rgb(r,g,b) _rgb((r)>>1,g,(b)>>1)
356:
357: #define L 0x1f /* low intensity */
358: #define H 0x3f /* high intensity */
359:
360: static uint16_t basic_color_map[] = {
361: rgb( 0, 0, 0), /* black */
362: rgb( L, 0, 0), /* red */
363: rgb( 0, L, 0), /* green */
364: rgb( L, L, 0), /* brown */
365: rgb( 0, 0, L), /* blue */
366: rgb( L, 0, L), /* magenta */
367: rgb( 0, L, L), /* cyan */
368: rgb( 0x31,0x31,0x31), /* white */
369:
370: rgb( L, L, L), /* black */
371: rgb( H, 0, 0), /* red */
372: rgb( 0, H, 0), /* green */
373: rgb( H, H, 0), /* brown */
374: rgb( 0, 0, H), /* blue */
375: rgb( H, 0, H), /* magenta */
376: rgb( 0, H, H), /* cyan */
377: rgb( H, H, H)
378: };
379:
380: #undef H
381: #undef L
382:
383: static void
384: init_palette(uint16_t *buf, int depth)
385: {
386: int i;
387:
388: /* convert RGB332 to RGB565 */
389: switch (depth) {
390: case 8:
391: case 4:
392: #if 0
393: for (i = 0; i <= 255; ++i) {
394: buf[i] = ((9 * ((i >> 5) & 0x07)) << 11) |
395: ((9 * ((i >> 2) & 0x07)) << 5) |
396: ((21 * (i & 0x03)) / 2);
397: }
398: #else
399: memcpy(buf, basic_color_map, sizeof basic_color_map);
400: for (i = 16; i < (1 << depth); ++i)
401: buf[i] = 0xffff;
402: #endif
403: break;
404: case 16:
405: /* palette is not needed */
406: break;
407: default:
408: /* other depths are not supported */
409: break;
410: }
411: }
412:
413: /*
414: * Create and initialize a new screen buffer.
415: */
416: int
417: pxa2x0_lcd_new_screen(struct pxa2x0_lcd_softc *sc,
418: struct pxa2x0_lcd_screen *scr, int depth)
419: {
420: bus_space_tag_t iot;
421: bus_space_handle_t ioh;
422: bus_dma_tag_t dma_tag;
423: const struct lcd_panel_geometry *geometry;
424: int width, height;
425: bus_size_t size;
426: int error, palette_size;
427: int busdma_flag = (cold ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
428: struct lcd_dma_descriptor *desc;
429: paddr_t buf_pa, desc_pa;
430:
431: if (sc != NULL) {
432: iot = sc->iot;
433: ioh = sc->ioh;
434: dma_tag = sc->dma_tag;
435: geometry = sc->geometry;
436: } else {
437: /* We are creating the console screen. */
438: iot = pxa2x0_lcd_console.iot;
439: ioh = pxa2x0_lcd_console.ioh;
440: dma_tag = pxa2x0_lcd_console.dma_tag;
441: geometry = pxa2x0_lcd_console.geometry;
442: }
443:
444: width = geometry->panel_width;
445: height = geometry->panel_height;
446: palette_size = 0;
447:
448: switch (depth) {
449: case 1:
450: case 2:
451: case 4:
452: case 8:
453: palette_size = (1 << depth) * sizeof (uint16_t);
454: /* FALLTHROUGH */
455: case 16:
456: size = roundup(width, 4) * depth / 8 * height;
457: break;
458: default:
459: printf("%s: Unknown depth (%d)\n",
460: sc != NULL ? sc->dev.dv_xname : "console", depth);
461: return (EINVAL);
462: }
463:
464: bzero(scr, sizeof *scr);
465:
466: scr->nsegs = 0;
467: scr->depth = depth;
468: scr->buf_size = size;
469: scr->buf_va = NULL;
470: size = roundup(size, 16) + 3 * sizeof (struct lcd_dma_descriptor)
471: + palette_size;
472:
473: error = bus_dmamem_alloc(dma_tag, size, 16, 0,
474: scr->segs, 1, &(scr->nsegs), busdma_flag);
475: if (error != 0 || scr->nsegs != 1) {
476: /* XXX: Actually we can handle nsegs > 1 case by means
477: of multiple DMA descriptors for a panel. It would
478: make code here a bit hairy */
479: if (error == 0)
480: error = E2BIG;
481: goto bad;
482: }
483:
484: error = bus_dmamem_map(dma_tag, scr->segs, scr->nsegs,
485: size, (caddr_t *)&(scr->buf_va), busdma_flag | BUS_DMA_COHERENT);
486: if (error != 0)
487: goto bad;
488:
489: memset(scr->buf_va, 0, scr->buf_size);
490:
491: /* map memory for DMA */
492: if (bus_dmamap_create(dma_tag, 1024 * 1024 * 2, 1,
493: 1024 * 1024 * 2, 0, busdma_flag, &scr->dma))
494: goto bad;
495: error = bus_dmamap_load(dma_tag, scr->dma,
496: scr->buf_va, size, NULL, busdma_flag);
497: if (error != 0) {
498: goto bad;
499: }
500:
501: buf_pa = scr->segs[0].ds_addr;
502: desc_pa = buf_pa + roundup(size, PAGE_SIZE) - 3 * sizeof *desc;
503:
504: /* make descriptors at the top of mapped memory */
505: desc = (struct lcd_dma_descriptor *)
506: ((caddr_t)(scr->buf_va) + roundup(size, PAGE_SIZE) -
507: 3 * sizeof *desc);
508:
509: desc[0].fdadr = desc_pa;
510: desc[0].fsadr = buf_pa;
511: desc[0].ldcmd = scr->buf_size;
512:
513: if (palette_size) {
514: init_palette((uint16_t *)((char *)desc - palette_size), depth);
515:
516: desc[2].fdadr = desc_pa; /* chain to panel 0 */
517: desc[2].fsadr = desc_pa - palette_size;
518: desc[2].ldcmd = palette_size | LDCMD_PAL;
519: }
520:
521: if (geometry->panel_info & LCDPANEL_DUAL) {
522: /* Dual panel */
523: desc[1].fdadr = desc_pa + sizeof *desc;
524: desc[1].fsadr = buf_pa + scr->buf_size / 2;
525: desc[0].ldcmd = desc[1].ldcmd = scr->buf_size / 2;
526:
527: }
528:
529: #if 0
530: desc[0].ldcmd |= LDCMD_SOFINT;
531: desc[1].ldcmd |= LDCMD_SOFINT;
532: #endif
533:
534: scr->dma_desc = desc;
535: scr->dma_desc_pa = desc_pa;
536: scr->map_size = size; /* used when unmap this. */
537:
538: if (sc != NULL) {
539: LIST_INSERT_HEAD(&(sc->screens), scr, link);
540: sc->n_screens++;
541: }
542:
543: return (0);
544:
545: bad:
546: if (scr->buf_va)
547: bus_dmamem_unmap(dma_tag, scr->buf_va, size);
548: if (scr->nsegs)
549: bus_dmamem_free(dma_tag, scr->segs, scr->nsegs);
550: return (error);
551: }
552:
553: /*
554: * Initialize rasops for a screen, as well as struct wsscreen_descr if this
555: * is the first screen creation.
556: */
557: void
558: pxa2x0_lcd_setup_rasops(struct rasops_info *rinfo,
559: struct pxa2x0_wsscreen_descr *descr,
560: const struct lcd_panel_geometry *geom)
561: {
562:
563: rinfo->ri_flg = descr->flags;
564: rinfo->ri_depth = descr->depth;
565: rinfo->ri_width = geom->panel_width;
566: rinfo->ri_height = geom->panel_height;
567: rinfo->ri_stride = rinfo->ri_width * rinfo->ri_depth / 8;
568: #ifdef notyet
569: rinfo->ri_wsfcookie = -1; /* XXX */
570: #endif
571:
572: /* swap B and R */
573: if (descr->depth == 16) {
574: rinfo->ri_rnum = 5;
575: rinfo->ri_rpos = 11;
576: rinfo->ri_gnum = 6;
577: rinfo->ri_gpos = 5;
578: rinfo->ri_bnum = 5;
579: rinfo->ri_bpos = 0;
580: }
581:
582: if (descr->c.nrows == 0) {
583: /* get rasops to compute screen size the first time */
584: rasops_init(rinfo, 100, 100);
585: } else
586: #ifndef __zaurus__
587: rasops_init(rinfo, descr->c.nrows, descr->c.ncols);
588: #else
589: /* XXX swap rows/cols for second call because of rotation */
590: rasops_init(rinfo, descr->c.ncols, descr->c.nrows);
591: #endif
592:
593: descr->c.nrows = rinfo->ri_rows;
594: descr->c.ncols = rinfo->ri_cols;
595: descr->c.capabilities = rinfo->ri_caps;
596: descr->c.textops = &rinfo->ri_ops;
597: }
598:
599: /*
600: * Early console attachment.
601: * This initializes the LCD, then creates and displays a screen buffer.
602: * This screen will be accounted for in the softc when the lcd device attaches.
603: */
604: int
605: pxa2x0_lcd_cnattach(struct pxa2x0_wsscreen_descr *descr,
606: const struct lcd_panel_geometry *geom, void (*clkman)(u_int, int))
607: {
608: struct rasops_info *ri;
609: long defattr;
610: int error;
611:
612: /* map controller registers */
613: pxa2x0_lcd_console.iot = &pxa2x0_bs_tag;
614: error = bus_space_map(pxa2x0_lcd_console.iot,
615: PXA2X0_LCDC_BASE, PXA2X0_LCDC_SIZE, 0, &pxa2x0_lcd_console.ioh);
616: if (error != 0)
617: return (error);
618:
619: pxa2x0_lcd_console.dma_tag = &pxa2x0_bus_dma_tag;
620: pxa2x0_lcd_console.geometry = geom;
621:
622: pxa2x0_lcd_initialize(pxa2x0_lcd_console.iot, pxa2x0_lcd_console.ioh,
623: pxa2x0_lcd_console.geometry, clkman);
624:
625: error = pxa2x0_lcd_new_screen(NULL, &pxa2x0_lcd_console.scr,
626: descr->depth);
627: if (error != 0)
628: return (error);
629:
630: ri = &pxa2x0_lcd_console.scr.rinfo;
631: ri->ri_hw = (void *)&pxa2x0_lcd_console.scr;
632: ri->ri_bits = pxa2x0_lcd_console.scr.buf_va;
633: pxa2x0_lcd_setup_rasops(ri, descr, pxa2x0_lcd_console.geometry);
634:
635: /* assumes 16 bpp */
636: ri->ri_ops.alloc_attr(ri, 0, 0, 0, &defattr);
637:
638: pxa2x0_lcd_start_dma(pxa2x0_lcd_console.iot, pxa2x0_lcd_console.ioh,
639: &pxa2x0_lcd_console.scr);
640:
641: wsdisplay_cnattach(&descr->c, ri, ri->ri_ccol, ri->ri_crow, defattr);
642:
643: return (0);
644: }
645:
646: /*
647: * Do the necessary accounting to bring the console variables in the softc.
648: */
649: void
650: pxa2x0_lcd_setup_console(struct pxa2x0_lcd_softc *sc,
651: const struct pxa2x0_wsscreen_descr *descr)
652: {
653: struct pxa2x0_lcd_screen *scr = &pxa2x0_lcd_console.scr;
654:
655: /*
656: * Register the console screen as if it had been created
657: * when the lcd device attached.
658: */
659: LIST_INSERT_HEAD(&(sc->screens), &pxa2x0_lcd_console.scr, link);
660: sc->n_screens++;
661: sc->active = scr;
662: }
663:
664: /*
665: * wsdisplay accessops
666: */
667:
668: int
669: pxa2x0_lcd_show_screen(void *v, void *cookie, int waitok,
670: void (*cb)(void *, int, int), void *cbarg)
671: {
672: struct pxa2x0_lcd_softc *sc = v;
673: struct rasops_info *ri = cookie;
674: struct pxa2x0_lcd_screen *scr = ri->ri_hw, *old;
675:
676: old = sc->active;
677: if (old == scr)
678: return 0;
679:
680: if (old)
681: pxa2x0_lcd_stop_dma(sc->iot, sc->ioh);
682:
683: pxa2x0_lcd_start_dma(sc->iot, sc->ioh, scr);
684:
685: sc->active = scr;
686: return 0;
687: }
688:
689: int
690: pxa2x0_lcd_alloc_screen(void *v, const struct wsscreen_descr *_type,
691: void **cookiep, int *curxp, int *curyp, long *attrp)
692: {
693: struct pxa2x0_lcd_softc *sc = v;
694: struct pxa2x0_lcd_screen *scr;
695: struct rasops_info *ri;
696: struct pxa2x0_wsscreen_descr *type =
697: (struct pxa2x0_wsscreen_descr *)_type;
698: int error;
699:
700: scr = malloc(sizeof *scr, M_DEVBUF, (cold ? M_NOWAIT : M_WAITOK));
701: if (scr == NULL)
702: return (ENOMEM);
703:
704: error = pxa2x0_lcd_new_screen(sc, scr, type->depth);
705: if (error != 0) {
706: free(scr, M_DEVBUF);
707: return (error);
708: }
709:
710: /*
711: * initialize raster operation for this screen.
712: */
713: ri = &scr->rinfo;
714: ri->ri_hw = (void *)scr;
715: ri->ri_bits = scr->buf_va;
716: pxa2x0_lcd_setup_rasops(ri, type, sc->geometry);
717:
718: /* assumes 16 bpp */
719: ri->ri_ops.alloc_attr(ri, 0, 0, 0, attrp);
720:
721: *cookiep = ri;
722: *curxp = 0;
723: *curyp = 0;
724:
725: return 0;
726: }
727:
728: void
729: pxa2x0_lcd_free_screen(void *v, void *cookie)
730: {
731: struct pxa2x0_lcd_softc *sc = v;
732: struct rasops_info *ri = cookie;
733: struct pxa2x0_lcd_screen *scr = ri->ri_hw;
734:
735: LIST_REMOVE(scr, link);
736: sc->n_screens--;
737: if (scr == sc->active) {
738: /* at first, we need to stop LCD DMA */
739: sc->active = NULL;
740:
741: #ifdef DEBUG
742: printf("lcd_free on active screen\n");
743: #endif
744:
745: pxa2x0_lcd_stop_dma(sc->iot, sc->ioh);
746: }
747:
748: if (scr->buf_va)
749: bus_dmamem_unmap(sc->dma_tag, scr->buf_va, scr->map_size);
750:
751: if (scr->nsegs > 0)
752: bus_dmamem_free(sc->dma_tag, scr->segs, scr->nsegs);
753:
754: free(scr, M_DEVBUF);
755: }
756:
757: int
758: pxa2x0_lcd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
759: {
760: struct pxa2x0_lcd_softc *sc = v;
761: struct wsdisplay_fbinfo *wsdisp_info;
762: struct pxa2x0_lcd_screen *scr = sc->active; /* ??? */
763:
764: switch (cmd) {
765: case WSDISPLAYIO_GTYPE:
766: *(u_int *)data = WSDISPLAY_TYPE_PXALCD; /* XXX */
767: break;
768:
769: case WSDISPLAYIO_GINFO:
770: wsdisp_info = (struct wsdisplay_fbinfo *)data;
771:
772: wsdisp_info->height = sc->geometry->panel_height;
773: wsdisp_info->width = sc->geometry->panel_width;
774: wsdisp_info->depth = 16; /* XXX */
775: wsdisp_info->cmsize = 0;
776: break;
777:
778: case WSDISPLAYIO_GETSUPPORTEDDEPTH:
779: *(u_int *)data = WSDISPLAYIO_DEPTH_16;
780: break;
781:
782: case WSDISPLAYIO_GETCMAP:
783: case WSDISPLAYIO_PUTCMAP:
784: return EINVAL; /* XXX Colormap */
785:
786: case WSDISPLAYIO_SVIDEO:
787: case WSDISPLAYIO_GVIDEO:
788: break;
789:
790: case WSDISPLAYIO_GCURPOS:
791: case WSDISPLAYIO_SCURPOS:
792: case WSDISPLAYIO_GCURMAX:
793: case WSDISPLAYIO_GCURSOR:
794: case WSDISPLAYIO_SCURSOR:
795: default:
796: return -1; /* not implemented */
797:
798: case WSDISPLAYIO_LINEBYTES:
799: *(u_int *)data = scr->rinfo.ri_stride;
800: break;
801: }
802: return (0);
803: }
804:
805: paddr_t
806: pxa2x0_lcd_mmap(void *v, off_t offset, int prot)
807: {
808: struct pxa2x0_lcd_softc *sc = v;
809: struct pxa2x0_lcd_screen *screen = sc->active; /* ??? */
810:
811: if ((offset & PAGE_MASK) != 0)
812: return (-1);
813:
814: if (screen == NULL)
815: return (-1);
816:
817: if (offset < 0 ||
818: offset >= screen->rinfo.ri_stride * screen->rinfo.ri_height)
819: return (-1);
820:
821: return (bus_dmamem_mmap(sc->dma_tag, screen->segs, screen->nsegs,
822: offset, prot, BUS_DMA_WAITOK | BUS_DMA_COHERENT));
823: }
824:
825: void
826: pxa2x0_lcd_suspend(struct pxa2x0_lcd_softc *sc)
827: {
828:
829: if (sc->active != NULL) {
830: pxa2x0_lcd_stop_dma(sc->iot, sc->ioh);
831:
832: pxa2x0_clkman_config(CKEN_LCD, 0);
833: }
834: }
835:
836: void
837: pxa2x0_lcd_resume(struct pxa2x0_lcd_softc *sc)
838: {
839:
840: if (sc->active != NULL) {
841: pxa2x0_lcd_initialize(sc->iot, sc->ioh, sc->geometry,
842: pxa2x0_clkman_config);
843: pxa2x0_lcd_start_dma(sc->iot, sc->ioh, sc->active);
844: }
845: }
846:
847: void
848: pxa2x0_lcd_power(int why, void *v)
849: {
850: struct pxa2x0_lcd_softc *sc = v;
851:
852: switch (why) {
853: case PWR_SUSPEND:
854: case PWR_STANDBY:
855: pxa2x0_lcd_suspend(sc);
856: break;
857:
858: case PWR_RESUME:
859: pxa2x0_lcd_resume(sc);
860: break;
861: }
862: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to pxa2x0_lcd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / arm / xscale