?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / sys / dev / tc / stic.c
blobcedb195c8c7de04abfe928111b00b02f0ba6a340
1 /* $NetBSD: stic.c,v 1.45 2008/07/09 13:19:33 joerg Exp $ */
2
3 /*-
4 * Copyright (c) 1999, 2000, 2001 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Andrew Doran.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * Driver for the DEC PixelStamp interface chip (STIC).
34 *
35 * XXX The bt459 interface shouldn't be replicated here.
36 */
37
38 #include <sys/cdefs.h>
39 __KERNEL_RCSID(0, "$NetBSD: stic.c,v 1.45 2008/07/09 13:19:33 joerg Exp $");
40
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/kernel.h>
44 #include <sys/device.h>
45 #include <sys/malloc.h>
46 #include <sys/buf.h>
47 #include <sys/ioctl.h>
48 #include <sys/callout.h>
49 #include <sys/conf.h>
50 #include <sys/kauth.h>
51 #include <sys/lwp.h>
52 #include <sys/event.h>
53
54 #include <uvm/uvm_extern.h>
55
56 #if defined(pmax)
57 #include <mips/cpuregs.h>
58 #elif defined(alpha)
59 #include <alpha/alpha_cpu.h>
60 #endif
61
62 #include <machine/vmparam.h>
63 #include <sys/bus.h>
64 #include <sys/intr.h>
65
66 #include <dev/wscons/wsconsio.h>
67 #include <dev/wscons/wsdisplayvar.h>
68
69 #include <dev/wsfont/wsfont.h>
70
71 #include <dev/ic/bt459reg.h>
72
73 #include <dev/tc/tcvar.h>
74 #include <dev/tc/sticreg.h>
75 #include <dev/tc/sticio.h>
76 #include <dev/tc/sticvar.h>
77
78 #define DUPBYTE0(x) ((((x)&0xff)<<16) | (((x)&0xff)<<8) | ((x)&0xff))
79 #define DUPBYTE1(x) ((((x)<<8)&0xff0000) | ((x)&0xff00) | (((x)>>8)&0xff))
80 #define DUPBYTE2(x) (((x)&0xff0000) | (((x)>>8)&0xff00) | (((x)>>16)&0xff))
81
82 #define PACK(p, o) ((p)[(o)] | ((p)[(o)+1] << 16))
83
84 #if defined(pmax)
85 #define machine_btop(x) mips_btop(x)
86 #elif defined(alpha)
87 #define machine_btop(x) alpha_btop(x)
88 #endif
89
90 /*
91 * N.B., Bt459 registers are 8bit width. Some of TC framebuffers have
92 * obscure register layout such as 2nd and 3rd Bt459 registers are
93 * adjacent each other in a word, i.e.,
94 * struct bt459triplet {
95 * struct {
96 * uint8_t u0;
97 * uint8_t u1;
98 * uint8_t u2;
99 * unsigned :8;
100 * } bt_lo;
101 * struct {
102 *
103 * Although HX has single Bt459, 32bit R/W can be done w/o any trouble.
104 * struct bt459reg {
105 * uint32_t bt_lo;
106 * uint32_t bt_hi;
107 * uint32_t bt_reg;
108 * uint32_t bt_cmap;
109 * };
110 *
111 */
112
113 /* Bt459 hardware registers */
114 #define bt_lo 0
115 #define bt_hi 1
116 #define bt_reg 2
117 #define bt_cmap 3
118
119 #define REG(base, index) *((volatile uint32_t *)(base) + (index))
120 #define SELECT(vdac, regno) do { \
121 REG(vdac, bt_lo) = DUPBYTE0(regno); \
122 REG(vdac, bt_hi) = DUPBYTE1(regno); \
123 tc_wmb(); \
124 } while (0)
125
126 static int sticioctl(void *, void *, u_long, void *, int, struct lwp *);
127 static int stic_alloc_screen(void *, const struct wsscreen_descr *,
128 void **, int *, int *, long *);
129 static void stic_free_screen(void *, void *);
130 static int stic_show_screen(void *, void *, int,
131 void (*)(void *, int, int), void *);
132
133 static void stic_do_switch(void *);
134 static void stic_setup_backing(struct stic_info *, struct stic_screen *);
135 static void stic_setup_vdac(struct stic_info *);
136 static void stic_clear_screen(struct stic_info *);
137
138 static int stic_get_cmap(struct stic_info *, struct wsdisplay_cmap *);
139 static int stic_set_cmap(struct stic_info *, struct wsdisplay_cmap *);
140 static int stic_set_cursor(struct stic_info *, struct wsdisplay_cursor *);
141 static int stic_get_cursor(struct stic_info *, struct wsdisplay_cursor *);
142 static void stic_set_curpos(struct stic_info *, struct wsdisplay_curpos *);
143 static void stic_set_hwcurpos(struct stic_info *);
144
145 static void stic_cursor(void *, int, int, int);
146 static void stic_copycols(void *, int, int, int, int);
147 static void stic_copyrows(void *, int, int, int);
148 static void stic_erasecols(void *, int, int, int, long);
149 static void stic_eraserows(void *, int, int, long);
150 static int stic_mapchar(void *, int, u_int *);
151 static void stic_putchar(void *, int, int, u_int, long);
152 static int stic_allocattr(void *, int, int, int, long *);
153
154 static dev_type_open(sticopen);
155 static dev_type_close(sticclose);
156 static dev_type_mmap(sticmmap);
157
158 const struct cdevsw stic_cdevsw = {
159 sticopen, sticclose, noread, nowrite, noioctl,
160 nostop, notty, nopoll, sticmmap, nokqfilter,
161 };
162
163 /* Colormap for wscons, matching WSCOL_*. Upper 8 are high-intensity. */
164 static const uint8_t stic_cmap[16*3] = {
165 0x00, 0x00, 0x00, /* black */
166 0x7f, 0x00, 0x00, /* red */
167 0x00, 0x7f, 0x00, /* green */
168 0x7f, 0x7f, 0x00, /* brown */
169 0x00, 0x00, 0x7f, /* blue */
170 0x7f, 0x00, 0x7f, /* magenta */
171 0x00, 0x7f, 0x7f, /* cyan */
172 0xc7, 0xc7, 0xc7, /* white */
173
174 0x7f, 0x7f, 0x7f, /* black */
175 0xff, 0x00, 0x00, /* red */
176 0x00, 0xff, 0x00, /* green */
177 0xff, 0xff, 0x00, /* brown */
178 0x00, 0x00, 0xff, /* blue */
179 0xff, 0x00, 0xff, /* magenta */
180 0x00, 0xff, 0xff, /* cyan */
181 0xff, 0xff, 0xff, /* white */
182 };
183
184 /*
185 * Compose 2 bit/pixel cursor image. Bit order will be reversed.
186 * M M M M I I I I M I M I M I M I
187 * [ before ] [ after ]
188 * 3 2 1 0 3 2 1 0 0 0 1 1 2 2 3 3
189 * 7 6 5 4 7 6 5 4 4 4 5 5 6 6 7 7
190 */
191 static const uint8_t shuffle[256] = {
192 0x00, 0x40, 0x10, 0x50, 0x04, 0x44, 0x14, 0x54,
193 0x01, 0x41, 0x11, 0x51, 0x05, 0x45, 0x15, 0x55,
194 0x80, 0xc0, 0x90, 0xd0, 0x84, 0xc4, 0x94, 0xd4,
195 0x81, 0xc1, 0x91, 0xd1, 0x85, 0xc5, 0x95, 0xd5,
196 0x20, 0x60, 0x30, 0x70, 0x24, 0x64, 0x34, 0x74,
197 0x21, 0x61, 0x31, 0x71, 0x25, 0x65, 0x35, 0x75,
198 0xa0, 0xe0, 0xb0, 0xf0, 0xa4, 0xe4, 0xb4, 0xf4,
199 0xa1, 0xe1, 0xb1, 0xf1, 0xa5, 0xe5, 0xb5, 0xf5,
200 0x08, 0x48, 0x18, 0x58, 0x0c, 0x4c, 0x1c, 0x5c,
201 0x09, 0x49, 0x19, 0x59, 0x0d, 0x4d, 0x1d, 0x5d,
202 0x88, 0xc8, 0x98, 0xd8, 0x8c, 0xcc, 0x9c, 0xdc,
203 0x89, 0xc9, 0x99, 0xd9, 0x8d, 0xcd, 0x9d, 0xdd,
204 0x28, 0x68, 0x38, 0x78, 0x2c, 0x6c, 0x3c, 0x7c,
205 0x29, 0x69, 0x39, 0x79, 0x2d, 0x6d, 0x3d, 0x7d,
206 0xa8, 0xe8, 0xb8, 0xf8, 0xac, 0xec, 0xbc, 0xfc,
207 0xa9, 0xe9, 0xb9, 0xf9, 0xad, 0xed, 0xbd, 0xfd,
208 0x02, 0x42, 0x12, 0x52, 0x06, 0x46, 0x16, 0x56,
209 0x03, 0x43, 0x13, 0x53, 0x07, 0x47, 0x17, 0x57,
210 0x82, 0xc2, 0x92, 0xd2, 0x86, 0xc6, 0x96, 0xd6,
211 0x83, 0xc3, 0x93, 0xd3, 0x87, 0xc7, 0x97, 0xd7,
212 0x22, 0x62, 0x32, 0x72, 0x26, 0x66, 0x36, 0x76,
213 0x23, 0x63, 0x33, 0x73, 0x27, 0x67, 0x37, 0x77,
214 0xa2, 0xe2, 0xb2, 0xf2, 0xa6, 0xe6, 0xb6, 0xf6,
215 0xa3, 0xe3, 0xb3, 0xf3, 0xa7, 0xe7, 0xb7, 0xf7,
216 0x0a, 0x4a, 0x1a, 0x5a, 0x0e, 0x4e, 0x1e, 0x5e,
217 0x0b, 0x4b, 0x1b, 0x5b, 0x0f, 0x4f, 0x1f, 0x5f,
218 0x8a, 0xca, 0x9a, 0xda, 0x8e, 0xce, 0x9e, 0xde,
219 0x8b, 0xcb, 0x9b, 0xdb, 0x8f, 0xcf, 0x9f, 0xdf,
220 0x2a, 0x6a, 0x3a, 0x7a, 0x2e, 0x6e, 0x3e, 0x7e,
221 0x2b, 0x6b, 0x3b, 0x7b, 0x2f, 0x6f, 0x3f, 0x7f,
222 0xaa, 0xea, 0xba, 0xfa, 0xae, 0xee, 0xbe, 0xfe,
223 0xab, 0xeb, 0xbb, 0xfb, 0xaf, 0xef, 0xbf, 0xff,
224 };
225
226 static const struct wsdisplay_accessops stic_accessops = {
227 sticioctl,
228 NULL, /* mmap */
229 stic_alloc_screen,
230 stic_free_screen,
231 stic_show_screen,
232 NULL, /* load_font */
233 };
234
235 static const struct wsdisplay_emulops stic_emulops = {
236 stic_cursor,
237 stic_mapchar,
238 stic_putchar,
239 stic_copycols,
240 stic_erasecols,
241 stic_copyrows,
242 stic_eraserows,
243 stic_allocattr
244 };
245
246 static struct wsscreen_descr stic_stdscreen = {
247 "std",
248 0, 0,
249 &stic_emulops,
250 0, 0,
251 WSSCREEN_WSCOLORS | WSSCREEN_HILIT
252 };
253
254 static const struct wsscreen_descr *_stic_scrlist[] = {
255 &stic_stdscreen,
256 };
257
258 static const struct wsscreen_list stic_screenlist = {
259 sizeof(_stic_scrlist) / sizeof(struct wsscreen_descr *), _stic_scrlist
260 };
261
262 struct stic_info stic_consinfo;
263 static struct stic_screen stic_consscr;
264 static struct stic_info *stic_info[STIC_MAXDV];
265 static int stic_unit;
266
267 void
268 stic_init(struct stic_info *si)
269 {
270 volatile uint32_t *vdac;
271 int i, cookie;
272
273 /* Reset the STIC & stamp(s). */
274 stic_reset(si);
275 vdac = si->si_vdac;
276
277 /* Hit it... */
278 SELECT(vdac, BT459_IREG_COMMAND_0);
279 REG(vdac, bt_reg) = 0x00c0c0c0; tc_wmb();
280
281 /* Now reset the VDAC. */
282 *si->si_vdac_reset = 0;
283 tc_wmb();
284 tc_syncbus();
285 DELAY(1000);
286
287 /* Finish the initialization. */
288 SELECT(vdac, BT459_IREG_COMMAND_1);
289 REG(vdac, bt_reg) = 0x00000000; tc_wmb();
290 REG(vdac, bt_reg) = 0x00c2c2c2; tc_wmb();
291 REG(vdac, bt_reg) = 0x00ffffff; tc_wmb();
292
293 for (i = 0; i < 7; i++) {
294 REG(vdac, bt_reg) = 0x00000000;
295 tc_wmb();
296 }
297
298 /* Set cursor colormap. */
299 SELECT(vdac, BT459_IREG_CCOLOR_1);
300 REG(vdac, bt_reg) = 0x00ffffff; tc_wmb();
301 REG(vdac, bt_reg) = 0x00ffffff; tc_wmb();
302 REG(vdac, bt_reg) = 0x00ffffff; tc_wmb();
303 REG(vdac, bt_reg) = 0x00000000; tc_wmb();
304 REG(vdac, bt_reg) = 0x00000000; tc_wmb();
305 REG(vdac, bt_reg) = 0x00000000; tc_wmb();
306 REG(vdac, bt_reg) = 0x00ffffff; tc_wmb();
307 REG(vdac, bt_reg) = 0x00ffffff; tc_wmb();
308 REG(vdac, bt_reg) = 0x00ffffff; tc_wmb();
309
310 /* Get a font and set up screen metrics. */
311 wsfont_init();
312
313 cookie = wsfont_find(NULL, 12, 0, 2, WSDISPLAY_FONTORDER_R2L,
314 WSDISPLAY_FONTORDER_L2R);
315 if (cookie <= 0)
316 cookie = wsfont_find(NULL, 0, 0, 2, WSDISPLAY_FONTORDER_R2L,
317 WSDISPLAY_FONTORDER_L2R);
318 if (cookie <= 0)
319 panic("stic_init: font table is empty");
320
321 if (wsfont_lock(cookie, &si->si_font))
322 panic("stic_init: couldn't lock font");
323
324 si->si_fontw = si->si_font->fontwidth;
325 si->si_fonth = si->si_font->fontheight;
326 si->si_consw = (1280 / si->si_fontw) & ~1;
327 si->si_consh = 1024 / si->si_fonth;
328 stic_stdscreen.ncols = si->si_consw;
329 stic_stdscreen.nrows = si->si_consh;
330
331 #ifdef DIAGNOSTIC
332 if ((u_int)si->si_fonth > 32 || (u_int)si->si_fontw > 16)
333 panic("stic_init: unusable font");
334 #endif
335
336 stic_setup_vdac(si);
337 stic_clear_screen(si);
338 si->si_dispmode = WSDISPLAYIO_MODE_EMUL;
339 }
340
341 void
342 stic_reset(struct stic_info *si)
343 {
344 int modtype, xconfig, yconfig, config;
345 volatile struct stic_regs *sr;
346
347 sr = si->si_stic;
348
349 /*
350 * Initialize the interface chip registers.
351 */
352 sr->sr_sticsr = 0x00000030; /* Get the STIC's attention. */
353 tc_wmb();
354 tc_syncbus();
355 DELAY(2000); /* wait 2ms for STIC to respond. */
356 sr->sr_sticsr = 0x00000000; /* Hit the STIC's csr again... */
357 tc_wmb();
358 sr->sr_buscsr = 0xffffffff; /* and bash its bus-acess csr. */
359 tc_wmb();
360 tc_syncbus(); /* Blam! */
361 DELAY(20000); /* wait until the stic recovers... */
362
363 modtype = sr->sr_modcl;
364 xconfig = (modtype & 0x800) >> 11;
365 yconfig = (modtype & 0x600) >> 9;
366 config = (yconfig << 1) | xconfig;
367 si->si_stampw = (xconfig ? 5 : 4);
368 si->si_stamph = (1 << yconfig);
369 si->si_stamphm = si->si_stamph - 1;
370 #ifdef notyet
371 si->si_option = (char)((modtype >> 12) & 3);
372 #endif
373
374 /* First PixelStamp */
375 si->si_stamp[0x000b0] = config;
376 si->si_stamp[0x000b4] = 0x0;
377
378 /* Second PixelStamp */
379 if (yconfig > 0) {
380 si->si_stamp[0x100b0] = config | 8;
381 si->si_stamp[0x100b4] = 0;
382 }
383
384 /*
385 * Initialize STIC video registers. Enable error and vertical
386 * retrace interrupts. Set the packet done flag so the Xserver will
387 * not time-out on the first packet submitted.
388 */
389 sr->sr_vblank = (1024 << 16) | 1063;
390 sr->sr_vsync = (1027 << 16) | 1030;
391 sr->sr_hblank = (255 << 16) | 340;
392 sr->sr_hsync2 = 245;
393 sr->sr_hsync = (261 << 16) | 293;
394 sr->sr_ipdvint =
395 STIC_INT_WE | STIC_INT_P | STIC_INT_E_EN | STIC_INT_V_EN;
396 sr->sr_sticsr = 8;
397 tc_wmb();
398 tc_syncbus();
399 }
400
401 void
402 stic_attach(device_t self, struct stic_info *si, int console)
403 {
404 struct wsemuldisplaydev_attach_args waa;
405
406 if (stic_unit < STIC_MAXDV) {
407 stic_info[stic_unit] = si;
408 si->si_unit = stic_unit++;
409 } else
410 si->si_unit = -1;
411
412 callout_init(&si->si_switch_callout, 0);
413
414 /*
415 * Allocate backing for the console. We could trawl back through
416 * msgbuf and and fill the backing, but it's not worth the hassle.
417 * We could also grab backing using pmap_steal_memory() early on,
418 * but that's a little ugly.
419 */
420 if (console)
421 stic_setup_backing(si, &stic_consscr);
422
423 waa.console = console;
424 waa.scrdata = &stic_screenlist;
425 waa.accessops = &stic_accessops;
426 waa.accesscookie = si;
427
428 config_found(self, &waa, wsemuldisplaydevprint);
429 }
430
431 void
432 stic_cnattach(struct stic_info *si)
433 {
434 struct stic_screen *ss;
435 long defattr;
436
437 ss = &stic_consscr;
438 si->si_curscreen = ss;
439 ss->ss_flags = SS_ALLOCED | SS_ACTIVE | SS_CURENB;
440 ss->ss_si = si;
441
442 si->si_flags |= SI_CURENB_CHANGED;
443 stic_flush(si);
444
445 stic_allocattr(ss, 0, 0, 0, &defattr);
446 stic_eraserows(ss, 0, si->si_consh, 0);
447 wsdisplay_cnattach(&stic_stdscreen, ss, 0, 0, defattr);
448 }
449
450 static void
451 stic_setup_vdac(struct stic_info *si)
452 {
453 uint8_t *ip, *mp;
454 int r, c, o, b, i, s;
455
456 s = spltty();
457
458 ip = (uint8_t *)si->si_cursor.cc_image;
459 mp = (uint8_t *)si->si_cursor.cc_mask;
460 memset(ip, 0, sizeof(si->si_cursor.cc_image));
461 memset(mp, 0, sizeof(si->si_cursor.cc_mask));
462
463 for (r = 0; r < si->si_fonth; r++) {
464 for (c = r & 1; c < si->si_fontw; c += 2) {
465 o = c >> 3;
466 b = 1 << (c & 7);
467 ip[o] |= b;
468 mp[o] |= b;
469 }
470
471 ip += 8;
472 mp += 8;
473 }
474
475 si->si_cursor.cc_size.x = 64;
476 si->si_cursor.cc_size.y = si->si_fonth;
477 si->si_cursor.cc_hot.x = 0;
478 si->si_cursor.cc_hot.y = 0;
479
480 si->si_cursor.cc_color[0] = 0xff;
481 si->si_cursor.cc_color[2] = 0xff;
482 si->si_cursor.cc_color[4] = 0xff;
483 si->si_cursor.cc_color[1] = 0x00;
484 si->si_cursor.cc_color[3] = 0x00;
485 si->si_cursor.cc_color[5] = 0x00;
486
487 memset(&si->si_cmap, 0, sizeof(si->si_cmap));
488 for (i = 0; i < 16; i++) {
489 si->si_cmap.r[i] = stic_cmap[i*3 + 0];
490 si->si_cmap.g[i] = stic_cmap[i*3 + 1];
491 si->si_cmap.b[i] = stic_cmap[i*3 + 2];
492 }
493
494 si->si_flags |= SI_CMAP_CHANGED | SI_CURSHAPE_CHANGED |
495 SI_CURCMAP_CHANGED;
496
497 splx(s);
498 }
499
500 static void
501 stic_clear_screen(struct stic_info *si)
502 {
503 uint32_t *pb;
504 int i;
505
506 /*
507 * Do this twice, since the first packet after a reset may be
508 * silently ignored.
509 */
510 for (i = 0; i < 2; i++) {
511 pb = (*si->si_pbuf_get)(si);
512
513 pb[0] = STAMP_CMD_LINES | STAMP_RGB_CONST | STAMP_LW_PERPACKET;
514 pb[1] = 0x01ffffff;
515 pb[2] = 0;
516 pb[3] = STAMP_UPDATE_ENABLE | STAMP_METHOD_COPY;
517 pb[4] = (1024 << 2) - 1;
518 pb[5] = 0;
519 pb[6] = 0;
520 pb[7] = (1280 << 19) | ((1024 << 3) + pb[4]);
521
522 (*si->si_pbuf_post)(si, pb);
523 }
524 }
525
526 static int
527 sticioctl(void *v, void *vs, u_long cmd, void *data, int flag, struct lwp *l)
528 {
529 struct stic_info *si;
530 int s;
531
532 si = v;
533
534 switch (cmd) {
535 case WSDISPLAYIO_GTYPE:
536 *(u_int *)data = si->si_disptype;
537 return (0);
538
539 case WSDISPLAYIO_GINFO:
540 #define wsd_fbip ((struct wsdisplay_fbinfo *)data)
541 wsd_fbip->height = 1024;
542 wsd_fbip->width = 1280;
543 wsd_fbip->depth = si->si_depth == 8 ? 8 : 32;
544 wsd_fbip->cmsize = CMAP_SIZE;
545 #undef fbt
546 return (0);
547
548 case WSDISPLAYIO_GETCMAP:
549 return (stic_get_cmap(si, (struct wsdisplay_cmap *)data));
550
551 case WSDISPLAYIO_PUTCMAP:
552 return (stic_set_cmap(si, (struct wsdisplay_cmap *)data));
553
554 case WSDISPLAYIO_SVIDEO:
555 #if 0 /* XXX later */
556 turnoff = *(int *)data == WSDISPLAYIO_VIDEO_OFF;
557 if ((si->si_blanked == 0) ^ turnoff)
558 si->si_blanked = turnoff;
559 #endif
560 return (0);
561
562 case WSDISPLAYIO_GVIDEO:
563 #if 0 /* XXX later */
564 *(u_int *)data = si->si_blanked ?
565 WSDISPLAYIO_VIDEO_OFF : WSDISPLAYIO_VIDEO_ON;
566 #endif
567 return (0);
568
569 case WSDISPLAYIO_GCURPOS:
570 *(struct wsdisplay_curpos *)data = si->si_cursor.cc_pos;
571 return (0);
572
573 case WSDISPLAYIO_SCURPOS:
574 stic_set_curpos(si, (struct wsdisplay_curpos *)data);
575 return (0);
576
577 case WSDISPLAYIO_GCURMAX:
578 ((struct wsdisplay_curpos *)data)->x =
579 ((struct wsdisplay_curpos *)data)->y = CURSOR_MAX_SIZE;
580 return (0);
581
582 case WSDISPLAYIO_GCURSOR:
583 return (stic_get_cursor(si, (struct wsdisplay_cursor *)data));
584
585 case WSDISPLAYIO_SCURSOR:
586 return (stic_set_cursor(si, (struct wsdisplay_cursor *)data));
587
588 case WSDISPLAYIO_SMODE:
589 si->si_dispmode = *(int *)data;
590 if (si->si_dispmode == WSDISPLAYIO_MODE_EMUL) {
591 (*si->si_ioctl)(si, STICIO_STOPQ, NULL, flag, l);
592 stic_setup_vdac(si);
593 s = spltty();
594 stic_flush(si);
595 splx(s);
596 stic_clear_screen(si);
597 stic_do_switch(si->si_curscreen);
598 }
599 return (0);
600
601 case STICIO_RESET:
602 stic_reset(si);
603 return (0);
604 }
605
606 if (si->si_ioctl != NULL)
607 return ((*si->si_ioctl)(si, cmd, data, flag, l));
608
609 return (EPASSTHROUGH);
610 }
611
612 static void
613 stic_setup_backing(struct stic_info *si, struct stic_screen *ss)
614 {
615 int size;
616
617 size = si->si_consw * si->si_consh * sizeof(*ss->ss_backing);
618 ss->ss_backing = malloc(size, M_DEVBUF, M_NOWAIT|M_ZERO);
619 }
620
621 static int
622 stic_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
623 int *curxp, int *curyp, long *attrp)
624 {
625 struct stic_info *si;
626 struct stic_screen *ss;
627
628 si = (struct stic_info *)v;
629
630 if ((stic_consscr.ss_flags & SS_ALLOCED) == 0)
631 ss = &stic_consscr;
632 else {
633 ss = malloc(sizeof(*ss), M_DEVBUF, M_WAITOK|M_ZERO);
634 }
635 stic_setup_backing(si, ss);
636
637 ss->ss_si = si;
638 ss->ss_flags = SS_ALLOCED | SS_CURENB;
639
640 *cookiep = ss;
641 *curxp = 0;
642 *curyp = 0;
643
644 stic_allocattr(ss, 0, 0, 0, attrp);
645 return (0);
646 }
647
648 static void
649 stic_free_screen(void *v, void *cookie)
650 {
651 struct stic_screen *ss;
652
653 ss = cookie;
654
655 #ifdef DIAGNOSTIC
656 if (ss == &stic_consscr)
657 panic("stic_free_screen: console");
658 if (ss == ((struct stic_info *)v)->si_curscreen)
659 panic("stic_free_screen: freeing current screen");
660 #endif
661
662 free(ss->ss_backing, M_DEVBUF);
663 free(ss, M_DEVBUF);
664 }
665
666 static int
667 stic_show_screen(void *v, void *cookie, int waitok,
668 void (*cb)(void *, int, int), void *cbarg)
669 {
670 struct stic_info *si;
671
672 si = (struct stic_info *)v;
673 if (si->si_switchcbarg != NULL)
674 return (EAGAIN);
675 si->si_switchcb = cb;
676 si->si_switchcbarg = cbarg;
677
678 if (cb != NULL) {
679 callout_reset(&si->si_switch_callout, 0, stic_do_switch,
680 cookie);
681 return (EAGAIN);
682 }
683
684 stic_do_switch(cookie);
685 return (0);
686 }
687
688 static void
689 stic_do_switch(void *cookie)
690 {
691 struct stic_screen *ss;
692 struct stic_info *si;
693 u_int r, c, nr, nc;
694 uint16_t *p, *sp;
695
696 ss = cookie;
697 si = ss->ss_si;
698
699 #ifdef DIAGNOSTIC
700 if (ss->ss_backing == NULL)
701 panic("stic_do_switch: screen not backed");
702 #endif
703
704 /* Swap in the new screen, and temporarily disable its backing. */
705 if (si->si_curscreen != NULL)
706 si->si_curscreen->ss_flags ^= SS_ACTIVE;
707 si->si_curscreen = ss;
708 ss->ss_flags |= SS_ACTIVE;
709 sp = ss->ss_backing;
710 ss->ss_backing = NULL;
711
712 /*
713 * We assume that most of the screen is blank and blast it with
714 * eraserows(), because eraserows() is cheap.
715 */
716 nr = si->si_consh;
717 stic_eraserows(ss, 0, nr, 0);
718
719 nc = si->si_consw;
720 p = sp;
721 for (r = 0; r < nr; r++)
722 for (c = 0; c < nc; c += 2, p += 2) {
723 if ((p[0] & 0xfff0) != 0)
724 stic_putchar(ss, r, c, p[0] >> 8,
725 p[0] & 0x00ff);
726 if ((p[1] & 0xfff0) != 0)
727 stic_putchar(ss, r, c + 1, p[1] >> 8,
728 p[1] & 0x00ff);
729 }
730
731 /*
732 * Re-enable the screen's backing, and move the cursor to the
733 * correct spot.
734 */
735 ss->ss_backing = sp;
736 si->si_cursor.cc_pos.x = ss->ss_curx;
737 si->si_cursor.cc_pos.y = ss->ss_cury;
738 stic_set_hwcurpos(si);
739 si->si_flags |= SI_CURENB_CHANGED;
740
741 /*
742 * XXX Since we don't yet receive vblank interrupts from the
743 * PXG, we must flush immediatley.
744 */
745 if (si->si_disptype == WSDISPLAY_TYPE_PXG)
746 stic_flush(si);
747
748 /* Tell wscons that we're done. */
749 if (si->si_switchcbarg != NULL) {
750 cookie = si->si_switchcbarg;
751 si->si_switchcbarg = NULL;
752 (*si->si_switchcb)(cookie, 0, 0);
753 }
754 }
755
756 static int
757 stic_allocattr(void *cookie, int fg, int bg, int flags, long *attr)
758 {
759 long tmp;
760
761 if ((flags & (WSATTR_BLINK | WSATTR_UNDERLINE)) != 0)
762 return (EINVAL);
763
764 if ((flags & WSATTR_WSCOLORS) == 0) {
765 fg = 7;
766 bg = 0;
767 }
768
769 if ((flags & WSATTR_HILIT) != 0)
770 fg += 8;
771
772 tmp = fg | (bg << 4);
773 *attr = tmp | (tmp << 16);
774 return (0);
775 }
776
777 static void
778 stic_erasecols(void *cookie, int row, int col, int num, long attr)
779 {
780 struct stic_info *si;
781 struct stic_screen *ss;
782 uint32_t *pb;
783 u_int i, linewidth;
784 uint16_t *p;
785
786 ss = cookie;
787 si = ss->ss_si;
788
789 if (ss->ss_backing != NULL) {
790 p = ss->ss_backing + row * si->si_consw + col;
791 for (i = num; i != 0; i--)
792 *p++ = (uint16_t)attr;
793 }
794 if ((ss->ss_flags & SS_ACTIVE) == 0)
795 return;
796
797 col = (col * si->si_fontw) << 19;
798 num = (num * si->si_fontw) << 19;
799 row = row * si->si_fonth;
800 attr = (attr & 0xf0) >> 4;
801 linewidth = (si->si_fonth << 2) - 1;
802 row = (row << 3) + linewidth;
803
804 pb = (*si->si_pbuf_get)(si);
805
806 pb[0] = STAMP_CMD_LINES | STAMP_RGB_CONST | STAMP_LW_PERPACKET;
807 pb[1] = 0x01ffffff;
808 pb[2] = 0;
809 pb[3] = STAMP_UPDATE_ENABLE | STAMP_METHOD_COPY;
810 pb[4] = linewidth;
811 pb[5] = DUPBYTE0(attr);
812 pb[6] = col | row;
813 pb[7] = (col + num) | row;
814
815 (*si->si_pbuf_post)(si, pb);
816 }
817
818 static void
819 stic_eraserows(void *cookie, int row, int num, long attr)
820 {
821 struct stic_info *si;
822 struct stic_screen *ss;
823 u_int linewidth, i;
824 uint32_t *pb;
825
826 ss = cookie;
827 si = ss->ss_si;
828
829 if (ss->ss_backing != NULL) {
830 pb = (uint32_t *)(ss->ss_backing + row * si->si_consw);
831 for (i = si->si_consw * num; i > 0; i -= 2)
832 *pb++ = (uint32_t)attr;
833 }
834 if ((ss->ss_flags & SS_ACTIVE) == 0)
835 return;
836
837 row *= si->si_fonth;
838 num *= si->si_fonth;
839 attr = (attr & 0xf0) >> 4;
840 linewidth = (num << 2) - 1;
841 row = (row << 3) + linewidth;
842
843 pb = (*si->si_pbuf_get)(si);
844
845 pb[0] = STAMP_CMD_LINES | STAMP_RGB_CONST | STAMP_LW_PERPACKET;
846 pb[1] = 0x01ffffff;
847 pb[2] = 0;
848 pb[3] = STAMP_UPDATE_ENABLE | STAMP_METHOD_COPY;
849 pb[4] = linewidth;
850 pb[5] = DUPBYTE0(attr);
851 pb[6] = row;
852 pb[7] = (1280 << 19) | row;
853
854 (*si->si_pbuf_post)(si, pb);
855 }
856
857 static void
858 stic_copyrows(void *cookie, int src, int dst, int height)
859 {
860 struct stic_info *si;
861 struct stic_screen *ss;
862 uint32_t *pb, *pbs;
863 u_int num, inc, adj;
864
865 ss = cookie;
866 si = ss->ss_si;
867
868 if (ss->ss_backing != NULL)
869 bcopy(ss->ss_backing + src * si->si_consw,
870 ss->ss_backing + dst * si->si_consw,
871 si->si_consw * sizeof(*ss->ss_backing) * height);
872 if ((ss->ss_flags & SS_ACTIVE) == 0)
873 return;
874
875 /*
876 * We need to do this in reverse if the destination row is below
877 * the source.
878 */
879 if (dst > src) {
880 src += height;
881 dst += height;
882 inc = -8;
883 adj = -1;
884 } else {
885 inc = 8;
886 adj = 0;
887 }
888
889 src = (src * si->si_fonth + adj) << 3;
890 dst = (dst * si->si_fonth + adj) << 3;
891 height *= si->si_fonth;
892
893 while (height > 0) {
894 num = (height < 255 ? height : 255);
895 height -= num;
896
897 pbs = (*si->si_pbuf_get)(si);
898 pb = pbs;
899
900 pb[0] = STAMP_CMD_COPYSPANS | STAMP_LW_PERPACKET;
901 pb[1] = (num << 24) | 0xffffff;
902 pb[2] = 0x0;
903 pb[3] = STAMP_UPDATE_ENABLE | STAMP_METHOD_COPY | STAMP_SPAN |
904 STAMP_COPYSPAN_ALIGNED;
905 pb[4] = 1; /* linewidth */
906
907 for (; num != 0; num--, src += inc, dst += inc, pb += 3) {
908 pb[5] = 1280 << 3;
909 pb[6] = src;
910 pb[7] = dst;
911 }
912
913 (*si->si_pbuf_post)(si, pbs);
914 }
915 }
916
917 static void
918 stic_copycols(void *cookie, int row, int src, int dst, int num)
919 {
920 struct stic_info *si;
921 struct stic_screen *ss;
922 u_int height, updword;
923 uint32_t *pb, *pbs;
924
925 ss = cookie;
926 si = ss->ss_si;
927
928 if (ss->ss_backing != NULL)
929 bcopy(ss->ss_backing + row * si->si_consw + src,
930 ss->ss_backing + row * si->si_consw + dst,
931 num * sizeof(*ss->ss_backing));
932 if ((ss->ss_flags & SS_ACTIVE) == 0)
933 return;
934
935 /*
936 * The stamp reads and writes left -> right only, so we need to
937 * buffer the span if the source and destination regions overlap
938 * and the source is left of the destination.
939 */
940 updword = STAMP_UPDATE_ENABLE | STAMP_METHOD_COPY | STAMP_SPAN;
941
942 if (src < dst && src + num > dst)
943 updword |= STAMP_HALF_BUFF;
944
945 row = (row * si->si_fonth) << 3;
946 num = (num * si->si_fontw) << 3;
947 src = row | ((src * si->si_fontw) << 19);
948 dst = row | ((dst * si->si_fontw) << 19);
949 height = si->si_fonth;
950
951 pbs = (*si->si_pbuf_get)(si);
952 pb = pbs;
953
954 pb[0] = STAMP_CMD_COPYSPANS | STAMP_LW_PERPACKET;
955 pb[1] = (height << 24) | 0xffffff;
956 pb[2] = 0x0;
957 pb[3] = updword;
958 pb[4] = 1; /* linewidth */
959
960 for ( ; height != 0; height--, src += 8, dst += 8, pb += 3) {
961 pb[5] = num;
962 pb[6] = src;
963 pb[7] = dst;
964 }
965
966 (*si->si_pbuf_post)(si, pbs);
967 }
968
969 static void
970 stic_putchar(void *cookie, int r, int c, u_int uc, long attr)
971 {
972 struct wsdisplay_font *font;
973 struct stic_screen *ss;
974 struct stic_info *si;
975 u_int i, bgcolor, fgcolor;
976 u_int *pb, v1, v2, xya;
977 u_short *fr;
978
979 ss = cookie;
980 si = ss->ss_si;
981
982 /* It's cheaper to use erasecols() to blit blanks. */
983 if (uc == 0) {
984 stic_erasecols(cookie, r, c, 1, attr);
985 return;
986 }
987
988 if (ss->ss_backing != NULL)
989 ss->ss_backing[r * si->si_consw + c] =
990 (u_short)((attr & 0xff) | (uc << 8));
991 if ((ss->ss_flags & SS_ACTIVE) == 0)
992 return;
993
994 font = si->si_font;
995 pb = (*si->si_pbuf_get)(si);
996
997 /*
998 * Create a mask from the glyph. Squeeze the foreground color
999 * through the mask, and then squeeze the background color through
1000 * the inverted mask. We may well read outside the glyph when
1001 * creating the mask, but it's bounded by the hardware so it
1002 * shouldn't matter a great deal...
1003 */
1004 pb[0] = STAMP_CMD_LINES | STAMP_RGB_FLAT | STAMP_XY_PERPRIMATIVE |
1005 STAMP_LW_PERPRIMATIVE;
1006 pb[1] = font->fontheight > 16 ? 0x04ffffff : 0x02ffffff;
1007 pb[2] = 0x0;
1008 pb[3] = STAMP_UPDATE_ENABLE | STAMP_WE_XYMASK | STAMP_METHOD_COPY;
1009
1010 r *= font->fontheight;
1011 c *= font->fontwidth;
1012 uc = (uc - font->firstchar) * font->stride * font->fontheight;
1013 fr = (u_short *)((char *)font->data + uc);
1014 bgcolor = DUPBYTE0((attr & 0xf0) >> 4);
1015 fgcolor = DUPBYTE0(attr & 0x0f);
1016
1017 i = ((font->fontheight > 16 ? 16 : font->fontheight) << 2) - 1;
1018 v1 = (c << 19) | ((r << 3) + i);
1019 v2 = ((c + font->fontwidth) << 19) | (v1 & 0xffff);
1020 xya = XYMASKADDR(si->si_stampw, si->si_stamphm, c, r, 0, 0);
1021
1022 pb[4] = PACK(fr, 0);
1023 pb[5] = PACK(fr, 2);
1024 pb[6] = PACK(fr, 4);
1025 pb[7] = PACK(fr, 6);
1026 pb[8] = PACK(fr, 8);
1027 pb[9] = PACK(fr, 10);
1028 pb[10] = PACK(fr, 12);
1029 pb[11] = PACK(fr, 14);
1030 pb[12] = xya;
1031 pb[13] = v1;
1032 pb[14] = v2;
1033 pb[15] = i;
1034 pb[16] = fgcolor;
1035
1036 pb[17] = ~pb[4];
1037 pb[18] = ~pb[5];
1038 pb[19] = ~pb[6];
1039 pb[20] = ~pb[7];
1040 pb[21] = ~pb[8];
1041 pb[22] = ~pb[9];
1042 pb[23] = ~pb[10];
1043 pb[24] = ~pb[11];
1044 pb[25] = xya;
1045 pb[26] = v1;
1046 pb[27] = v2;
1047 pb[28] = i;
1048 pb[29] = bgcolor;
1049
1050 /* Two more squeezes for the lower part of the character. */
1051 if (font->fontheight > 16) {
1052 i = ((font->fontheight - 16) << 2) - 1;
1053 r += 16;
1054 v1 = (c << 19) | ((r << 3) + i);
1055 v2 = ((c + font->fontwidth) << 19) | (v1 & 0xffff);
1056
1057 pb[30] = PACK(fr, 16);
1058 pb[31] = PACK(fr, 18);
1059 pb[32] = PACK(fr, 20);
1060 pb[33] = PACK(fr, 22);
1061 pb[34] = PACK(fr, 24);
1062 pb[35] = PACK(fr, 26);
1063 pb[36] = PACK(fr, 28);
1064 pb[37] = PACK(fr, 30);
1065 pb[38] = xya;
1066 pb[39] = v1;
1067 pb[40] = v2;
1068 pb[41] = i;
1069 pb[42] = fgcolor;
1070
1071 pb[43] = ~pb[30];
1072 pb[44] = ~pb[31];
1073 pb[45] = ~pb[32];
1074 pb[46] = ~pb[33];
1075 pb[47] = ~pb[34];
1076 pb[48] = ~pb[35];
1077 pb[49] = ~pb[36];
1078 pb[50] = ~pb[37];
1079 pb[51] = xya;
1080 pb[52] = v1;
1081 pb[53] = v2;
1082 pb[54] = i;
1083 pb[55] = bgcolor;
1084 }
1085
1086 (*si->si_pbuf_post)(si, pb);
1087 }
1088
1089 static int
1090 stic_mapchar(void *cookie, int c, u_int *cp)
1091 {
1092 struct stic_info *si;
1093
1094 si = ((struct stic_screen *)cookie)->ss_si;
1095
1096 if (c < si->si_font->firstchar || c == ' ') {
1097 *cp = 0;
1098 return (0);
1099 }
1100
1101 if (c - si->si_font->firstchar >= si->si_font->numchars) {
1102 *cp = 0;
1103 return (0);
1104 }
1105
1106 *cp = c;
1107 return (5);
1108 }
1109
1110 static void
1111 stic_cursor(void *cookie, int on, int row, int col)
1112 {
1113 struct stic_screen *ss;
1114 struct stic_info *si;
1115 int s;
1116
1117 ss = cookie;
1118 si = ss->ss_si;
1119
1120 ss->ss_curx = col * si->si_fontw;
1121 ss->ss_cury = row * si->si_fonth;
1122
1123 s = spltty();
1124
1125 if (on)
1126 ss->ss_flags |= SS_CURENB;
1127 else
1128 ss->ss_flags &= ~SS_CURENB;
1129
1130 if ((ss->ss_flags & SS_ACTIVE) != 0) {
1131 si->si_cursor.cc_pos.x = ss->ss_curx;
1132 si->si_cursor.cc_pos.y = ss->ss_cury;
1133 si->si_flags |= SI_CURENB_CHANGED;
1134 stic_set_hwcurpos(si);
1135
1136 /*
1137 * XXX Since we don't yet receive vblank interrupts from the
1138 * PXG, we must flush immediatley.
1139 */
1140 if (si->si_disptype == WSDISPLAY_TYPE_PXG)
1141 stic_flush(si);
1142 }
1143
1144 splx(s);
1145 }
1146
1147 void
1148 stic_flush(struct stic_info *si)
1149 {
1150 volatile uint32_t *vdac;
1151 int v;
1152
1153 if ((si->si_flags & SI_ALL_CHANGED) == 0)
1154 return;
1155
1156 vdac = si->si_vdac;
1157 v = si->si_flags;
1158 si->si_flags &= ~SI_ALL_CHANGED;
1159
1160 if ((v & SI_CURENB_CHANGED) != 0) {
1161 SELECT(vdac, BT459_IREG_CCR);
1162 if ((si->si_curscreen->ss_flags & SS_CURENB) != 0)
1163 REG(vdac, bt_reg) = 0x00c0c0c0;
1164 else
1165 REG(vdac, bt_reg) = 0x00000000;
1166 tc_wmb();
1167 }
1168
1169 if ((v & SI_CURCMAP_CHANGED) != 0) {
1170 uint8_t *cp;
1171
1172 cp = si->si_cursor.cc_color;
1173
1174 SELECT(vdac, BT459_IREG_CCOLOR_2);
1175 REG(vdac, bt_reg) = DUPBYTE0(cp[1]); tc_wmb();
1176 REG(vdac, bt_reg) = DUPBYTE0(cp[3]); tc_wmb();
1177 REG(vdac, bt_reg) = DUPBYTE0(cp[5]); tc_wmb();
1178 REG(vdac, bt_reg) = DUPBYTE0(cp[0]); tc_wmb();
1179 REG(vdac, bt_reg) = DUPBYTE0(cp[2]); tc_wmb();
1180 REG(vdac, bt_reg) = DUPBYTE0(cp[4]); tc_wmb();
1181 }
1182
1183 if ((v & SI_CURSHAPE_CHANGED) != 0) {
1184 uint8_t *ip, *mp, img, msk;
1185 uint8_t u;
1186 int bcnt;
1187
1188 ip = (uint8_t *)si->si_cursor.cc_image;
1189 mp = (uint8_t *)si->si_cursor.cc_mask;
1190
1191 bcnt = 0;
1192 SELECT(vdac, BT459_IREG_CRAM_BASE);
1193 /* 64 pixel scan line is consisted with 16 byte cursor ram */
1194 while (bcnt < CURSOR_MAX_SIZE * 16) {
1195 img = *ip++;
1196 msk = *mp++;
1197 img &= msk; /* cookie off image */
1198 u = (msk & 0x0f) << 4 | (img & 0x0f);
1199 REG(vdac, bt_reg) = DUPBYTE0(shuffle[u]);
1200 tc_wmb();
1201 u = (msk & 0xf0) | (img & 0xf0) >> 4;
1202 REG(vdac, bt_reg) = DUPBYTE0(shuffle[u]);
1203 tc_wmb();
1204 bcnt += 2;
1205 }
1206 }
1207
1208 if ((v & SI_CMAP_CHANGED) != 0) {
1209 struct stic_hwcmap256 *cm;
1210 int index;
1211
1212 cm = &si->si_cmap;
1213
1214 SELECT(vdac, 0);
1215 SELECT(vdac, 0);
1216 for (index = 0; index < CMAP_SIZE; index++) {
1217 REG(vdac, bt_cmap) = DUPBYTE0(cm->r[index]);
1218 tc_wmb();
1219 REG(vdac, bt_cmap) = DUPBYTE0(cm->g[index]);
1220 tc_wmb();
1221 REG(vdac, bt_cmap) = DUPBYTE0(cm->b[index]);
1222 tc_wmb();
1223 }
1224 }
1225 }
1226
1227 static int
1228 stic_get_cmap(struct stic_info *si, struct wsdisplay_cmap *p)
1229 {
1230 u_int index = p->index, count = p->count;
1231 int error;
1232
1233 if (index >= CMAP_SIZE || count > CMAP_SIZE - index)
1234 return (EINVAL);
1235
1236 error = copyout(&si->si_cmap.r[index], p->red, count);
1237 if (error)
1238 return error;
1239 error = copyout(&si->si_cmap.g[index], p->green, count);
1240 if (error)
1241 return error;
1242 error = copyout(&si->si_cmap.b[index], p->blue, count);
1243 return error;
1244 }
1245
1246 static int
1247 stic_set_cmap(struct stic_info *si, struct wsdisplay_cmap *p)
1248 {
1249 struct stic_hwcmap256 cmap;
1250 u_int index, count;
1251 int s, error;
1252
1253 index = p->index;
1254 count = p->count;
1255
1256 if (index >= CMAP_SIZE || count > CMAP_SIZE - index)
1257 return (EINVAL);
1258
1259 error = copyin(p->red, &cmap.r[index], count);
1260 if (error)
1261 return error;
1262 error = copyin(p->green, &cmap.g[index], count);
1263 if (error)
1264 return error;
1265 error = copyin(p->blue, &cmap.b[index], count);
1266 if (error)
1267 return error;
1268
1269 s = spltty();
1270 memcpy(&si->si_cmap.r[index], &cmap.r[index], count);
1271 memcpy(&si->si_cmap.g[index], &cmap.g[index], count);
1272 memcpy(&si->si_cmap.b[index], &cmap.b[index], count);
1273 si->si_flags |= SI_CMAP_CHANGED;
1274 splx(s);
1275
1276 /*
1277 * XXX Since we don't yet receive vblank interrupts from the PXG, we
1278 * must flush immediatley.
1279 */
1280 if (si->si_disptype == WSDISPLAY_TYPE_PXG)
1281 stic_flush(si);
1282
1283 return (0);
1284 }
1285
1286 static int
1287 stic_set_cursor(struct stic_info *si, struct wsdisplay_cursor *p)
1288 {
1289 #define cc (&si->si_cursor)
1290 u_int v, index = 0, count = 0, icount = 0;
1291 struct stic_screen *ss;
1292 uint8_t r[2], g[2], b[2], image[512], mask[512];
1293 int s, error;
1294
1295 v = p->which;
1296 ss = si->si_curscreen;
1297 if ((v & WSDISPLAY_CURSOR_DOCMAP) != 0) {
1298 index = p->cmap.index;
1299 count = p->cmap.count;
1300 if (index >= 2 || (index + count) > 2)
1301 return (EINVAL);
1302 error = copyin(p->cmap.red, &r[index], count);
1303 if (error)
1304 return error;
1305 error = copyin(p->cmap.green, &g[index], count);
1306 if (error)
1307 return error;
1308 error = copyin(p->cmap.blue, &b[index], count);
1309 if (error)
1310 return error;
1311 }
1312 if ((v & WSDISPLAY_CURSOR_DOSHAPE) != 0) {
1313 if (p->size.x > CURSOR_MAX_SIZE || p->size.y > CURSOR_MAX_SIZE)
1314 return (EINVAL);
1315 icount = ((p->size.x < 33) ? 4 : 8) * p->size.y;
1316 error = copyin(p->image, image, icount);
1317 if (error)
1318 return error;
1319 error = copyin(p->mask, mask, icount);
1320 if (error)
1321 return error;
1322 }
1323 if ((v & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOCUR)) != 0) {
1324 if (v & WSDISPLAY_CURSOR_DOCUR)
1325 cc->cc_hot = p->hot;
1326 if (v & WSDISPLAY_CURSOR_DOPOS)
1327 stic_set_curpos(si, &p->pos);
1328 }
1329
1330 s = spltty();
1331 if ((v & WSDISPLAY_CURSOR_DOCUR) != 0) {
1332 if (p->enable)
1333 ss->ss_flags |= SS_CURENB;
1334 else
1335 ss->ss_flags &= ~SS_CURENB;
1336 si->si_flags |= SI_CURENB_CHANGED;
1337 }
1338 if ((v & WSDISPLAY_CURSOR_DOCMAP) != 0) {
1339 memcpy(&cc->cc_color[index], &r[index], count);
1340 memcpy(&cc->cc_color[index + 2], &g[index], count);
1341 memcpy(&cc->cc_color[index + 4], &b[index], count);
1342 si->si_flags |= SI_CURCMAP_CHANGED;
1343 }
1344 if ((v & WSDISPLAY_CURSOR_DOSHAPE) != 0) {
1345 memset(cc->cc_image, 0, sizeof cc->cc_image);
1346 memcpy(cc->cc_image, image, icount);
1347 memset(cc->cc_mask, 0, sizeof cc->cc_mask);
1348 memcpy(cc->cc_mask, mask, icount);
1349 si->si_flags |= SI_CURSHAPE_CHANGED;
1350 }
1351 splx(s);
1352
1353 /*
1354 * XXX Since we don't yet receive vblank interrupts from the PXG, we
1355 * must flush immediatley.
1356 */
1357 if (si->si_disptype == WSDISPLAY_TYPE_PXG)
1358 stic_flush(si);
1359
1360 return (0);
1361 #undef cc
1362 }
1363
1364 static int
1365 stic_get_cursor(struct stic_info *si, struct wsdisplay_cursor *p)
1366 {
1367
1368 /* XXX */
1369 return (EPASSTHROUGH);
1370 }
1371
1372 static void
1373 stic_set_curpos(struct stic_info *si, struct wsdisplay_curpos *curpos)
1374 {
1375 int x, y;
1376
1377 x = curpos->x;
1378 y = curpos->y;
1379
1380 if (y < 0)
1381 y = 0;
1382 else if (y > 1023)
1383 y = 1023;
1384 if (x < 0)
1385 x = 0;
1386 else if (x > 1279)
1387 x = 1279;
1388
1389 si->si_cursor.cc_pos.x = x;
1390 si->si_cursor.cc_pos.y = y;
1391 stic_set_hwcurpos(si);
1392 }
1393
1394 static void
1395 stic_set_hwcurpos(struct stic_info *si)
1396 {
1397 volatile uint32_t *vdac;
1398 int x, y, s;
1399
1400 vdac = si->si_vdac;
1401
1402 x = si->si_cursor.cc_pos.x - si->si_cursor.cc_hot.x;
1403 y = si->si_cursor.cc_pos.y - si->si_cursor.cc_hot.y;
1404 x += STIC_MAGIC_X;
1405 y += STIC_MAGIC_Y;
1406
1407 s = spltty();
1408 SELECT(vdac, BT459_IREG_CURSOR_X_LOW);
1409 REG(vdac, bt_reg) = DUPBYTE0(x); tc_wmb();
1410 REG(vdac, bt_reg) = DUPBYTE1(x); tc_wmb();
1411 REG(vdac, bt_reg) = DUPBYTE0(y); tc_wmb();
1412 REG(vdac, bt_reg) = DUPBYTE1(y); tc_wmb();
1413 splx(s);
1414 }
1415
1416 /*
1417 * STIC control inteface. We have a separate device for mapping the board,
1418 * because access to the DMA engine means that it's possible to circumvent
1419 * the securelevel mechanism.
1420 */
1421 static int
1422 sticopen(dev_t dev, int flag, int mode, struct lwp *l)
1423 {
1424 struct stic_info *si;
1425 int s, error;
1426
1427 error = kauth_authorize_device_passthru(l->l_cred, dev,
1428 KAUTH_REQ_DEVICE_RAWIO_PASSTHRU_ALL, NULL);
1429 if (error)
1430 return (error);
1431 if (minor(dev) >= STIC_MAXDV)
1432 return (ENXIO);
1433 if ((si = stic_info[minor(dev)]) == NULL)
1434 return (ENXIO);
1435
1436 s = spltty();
1437 if ((si->si_flags & SI_DVOPEN) != 0) {
1438 splx(s);
1439 return (EBUSY);
1440 }
1441 si->si_flags |= SI_DVOPEN;
1442 splx(s);
1443
1444 return (0);
1445 }
1446
1447 static int
1448 sticclose(dev_t dev, int flag, int mode, struct lwp *l)
1449 {
1450 struct stic_info *si;
1451 int s;
1452
1453 si = stic_info[minor(dev)];
1454 s = spltty();
1455 si->si_flags &= ~SI_DVOPEN;
1456 splx(s);
1457
1458 return (0);
1459 }
1460
1461 static paddr_t
1462 sticmmap(dev_t dev, off_t offset, int prot)
1463 {
1464 struct stic_info *si;
1465 struct stic_xmap *sxm;
1466 paddr_t pa;
1467
1468 si = stic_info[minor(dev)];
1469 sxm = NULL;
1470
1471 if (si->si_dispmode != WSDISPLAYIO_MODE_MAPPED)
1472 return (-1L);
1473
1474 if (offset < 0)
1475 return ((paddr_t)-1L);
1476
1477 if (offset < sizeof(sxm->sxm_stic)) {
1478 pa = STIC_KSEG_TO_PHYS(si->si_stic);
1479 return (machine_btop(pa + offset));
1480 }
1481 offset -= sizeof(sxm->sxm_stic);
1482
1483 if (offset < sizeof(sxm->sxm_poll)) {
1484 pa = STIC_KSEG_TO_PHYS(si->si_slotbase);
1485 return (machine_btop(pa + offset));
1486 }
1487 offset -= sizeof(sxm->sxm_poll);
1488
1489 if (offset < si->si_buf_size)
1490 return (machine_btop(si->si_buf_phys + offset));
1491
1492 return ((paddr_t)-1L);
1493 }
NetBSD on the FriendlyARM MINI2440