Annotation of sys/dev/ic/bt485.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: bt485.c,v 1.12 2002/11/09 22:51:48 miod Exp $ */
2: /* $NetBSD: bt485.c,v 1.2 2000/04/02 18:55:01 nathanw Exp $ */
3:
4: /*
5: * Copyright (c) 1995, 1996 Carnegie-Mellon University.
6: * All rights reserved.
7: *
8: * Author: Chris G. Demetriou
9: *
10: * Permission to use, copy, modify and distribute this software and
11: * its documentation is hereby granted, provided that both the copyright
12: * notice and this permission notice appear in all copies of the
13: * software, derivative works or modified versions, and any portions
14: * thereof, and that both notices appear in supporting documentation.
15: *
16: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
17: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
18: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
19: *
20: * Carnegie Mellon requests users of this software to return to
21: *
22: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
23: * School of Computer Science
24: * Carnegie Mellon University
25: * Pittsburgh PA 15213-3890
26: *
27: * any improvements or extensions that they make and grant Carnegie the
28: * rights to redistribute these changes.
29: */
30:
31: /* This code was derived from and originally located in sys/dev/pci/
32: * NetBSD: tga_bt485.c,v 1.4 1999/03/24 05:51:21 mrg Exp
33: */
34:
35: #include <sys/param.h>
36: #include <sys/systm.h>
37: #include <sys/device.h>
38: #include <sys/buf.h>
39: #include <sys/kernel.h>
40: #include <sys/malloc.h>
41:
42: #include <uvm/uvm_extern.h>
43:
44: #include <dev/pci/pcivar.h>
45: #include <dev/ic/bt485reg.h>
46: #include <dev/ic/bt485var.h>
47: #include <dev/ic/ramdac.h>
48:
49: #include <dev/wscons/wsconsio.h>
50: #include <dev/wscons/wsdisplayvar.h>
51: #include <dev/rasops/rasops.h>
52:
53: /*
54: * Functions exported via the RAMDAC configuration table.
55: */
56: void bt485_init(struct ramdac_cookie *);
57: int bt485_set_cmap(struct ramdac_cookie *,
58: struct wsdisplay_cmap *);
59: int bt485_get_cmap(struct ramdac_cookie *,
60: struct wsdisplay_cmap *);
61: int bt485_set_cursor(struct ramdac_cookie *,
62: struct wsdisplay_cursor *);
63: int bt485_get_cursor(struct ramdac_cookie *,
64: struct wsdisplay_cursor *);
65: int bt485_set_curpos(struct ramdac_cookie *,
66: struct wsdisplay_curpos *);
67: int bt485_get_curpos(struct ramdac_cookie *,
68: struct wsdisplay_curpos *);
69: int bt485_get_curmax(struct ramdac_cookie *,
70: struct wsdisplay_curpos *);
71:
72: /* XXX const */
73: struct ramdac_funcs bt485_funcsstruct = {
74: "Bt485",
75: bt485_register,
76: bt485_init,
77: bt485_set_cmap,
78: bt485_get_cmap,
79: bt485_set_cursor,
80: bt485_get_cursor,
81: bt485_set_curpos,
82: bt485_get_curpos,
83: bt485_get_curmax,
84: NULL, /* check_curcmap; not needed */
85: NULL, /* set_curcmap; not needed */
86: NULL, /* get_curcmap; not needed */
87: NULL, /* no dot clock to set */
88: };
89:
90: /*
91: * Private data.
92: */
93: struct bt485data {
94: void *cookie; /* This is what is passed
95: * around, and is probably
96: * struct tga_devconfig *
97: */
98:
99: int (*ramdac_sched_update)(void *, void (*)(void *));
100: void (*ramdac_wr)(void *, u_int, u_int8_t);
101: u_int8_t (*ramdac_rd)(void *, u_int);
102:
103: int changed; /* what changed; see below */
104: int curenb; /* cursor enabled */
105: struct wsdisplay_curpos curpos; /* current cursor position */
106: struct wsdisplay_curpos curhot; /* cursor hotspot */
107: char curcmap_r[2]; /* cursor colormap */
108: char curcmap_g[2];
109: char curcmap_b[2];
110: struct wsdisplay_curpos cursize; /* current cursor size */
111: char curimage[512]; /* cursor image data */
112: char curmask[512]; /* cursor mask data */
113: char cmap_r[256]; /* colormap */
114: char cmap_g[256];
115: char cmap_b[256];
116: };
117:
118: #define DATA_ENB_CHANGED 0x01 /* cursor enable changed */
119: #define DATA_CURCMAP_CHANGED 0x02 /* cursor colormap changed */
120: #define DATA_CURSHAPE_CHANGED 0x04 /* cursor size, image, mask changed */
121: #define DATA_CMAP_CHANGED 0x08 /* colormap changed */
122: #define DATA_ALL_CHANGED 0x0f
123:
124: #define CURSOR_MAX_SIZE 64
125:
126: /*
127: * Internal functions.
128: */
129: inline void bt485_wr_i(struct bt485data *, u_int8_t, u_int8_t);
130: inline u_int8_t bt485_rd_i(struct bt485data *, u_int8_t);
131: void bt485_update(void *);
132: void bt485_update_curpos(struct bt485data *);
133:
134: /*****************************************************************************/
135:
136: /*
137: * Functions exported via the RAMDAC configuration table.
138: */
139:
140: struct ramdac_funcs *
141: bt485_funcs(void)
142: {
143: return &bt485_funcsstruct;
144: }
145:
146: struct ramdac_cookie *
147: bt485_register(v, sched_update, wr, rd)
148: void *v;
149: int (*sched_update)(void *, void (*)(void *));
150: void (*wr)(void *, u_int, u_int8_t);
151: u_int8_t (*rd)(void *, u_int);
152: {
153: struct bt485data *data;
154: /*
155: * XXX -- comment out of date. rcd.
156: * If we should allocate a new private info struct, do so.
157: * Otherwise, use the one we have (if it's there), or
158: * use the temporary one on the stack.
159: */
160: data = malloc(sizeof *data, M_DEVBUF, M_WAITOK);
161: /* XXX -- if !data */
162: data->cookie = v;
163: data->ramdac_sched_update = sched_update;
164: data->ramdac_wr = wr;
165: data->ramdac_rd = rd;
166: return (struct ramdac_cookie *)data;
167: }
168:
169: /*
170: * This function exists solely to provide a means to init
171: * the RAMDAC without first registering. It is useful for
172: * initializing the console early on.
173: */
174: void
175: bt485_cninit(v, sched_update, wr, rd)
176: void *v;
177: int (*sched_update)(void *, void (*)(void *));
178: void (*wr)(void *, u_int, u_int8_t);
179: u_int8_t (*rd)(void *, u_int);
180: {
181: struct bt485data tmp, *data = &tmp;
182: data->cookie = v;
183: data->ramdac_sched_update = sched_update;
184: data->ramdac_wr = wr;
185: data->ramdac_rd = rd;
186: bt485_init((struct ramdac_cookie *)data);
187: }
188:
189: void
190: bt485_init(rc)
191: struct ramdac_cookie *rc;
192: {
193: u_int8_t regval;
194: struct bt485data *data = (struct bt485data *)rc;
195: int i;
196:
197: /*
198: * Init the BT485 for normal operation.
199: */
200:
201: /*
202: * Allow indirect register access. (Actually, this is
203: * already enabled. In fact, if it is _disabled_, for
204: * some reason the monitor appears to lose sync!!! (?!?!)
205: */
206: regval = data->ramdac_rd(data->cookie, BT485_REG_COMMAND_0);
207: regval |= 0x80;
208: /*
209: * Set the RAMDAC to 8 bit resolution, rather than 6 bit
210: * resolution.
211: */
212: regval |= 0x02;
213: data->ramdac_wr(data->cookie, BT485_REG_COMMAND_0, regval);
214:
215: /* Set the RAMDAC to 8BPP (no interestion options). */
216: data->ramdac_wr(data->cookie, BT485_REG_COMMAND_1, 0x40);
217:
218: /* Disable the cursor (for now) */
219: regval = data->ramdac_rd(data->cookie, BT485_REG_COMMAND_2);
220: regval &= ~0x03;
221: regval |= 0x24;
222: data->ramdac_wr(data->cookie, BT485_REG_COMMAND_2, regval);
223:
224: /* Use a 64x64x2 cursor */
225: regval = bt485_rd_i(data, BT485_IREG_COMMAND_3);
226: regval |= 0x04;
227: regval |= 0x08;
228: bt485_wr_i(data, BT485_IREG_COMMAND_3, regval);
229:
230: /* Set the Pixel Mask to something useful */
231: data->ramdac_wr(data->cookie, BT485_REG_PIXMASK, 0xff);
232:
233: /*
234: * Initalize the RAMDAC info struct to hold all of our
235: * data, and fill it in.
236: */
237: data->changed = DATA_ALL_CHANGED;
238:
239: data->curenb = 0; /* cursor disabled */
240: data->curpos.x = data->curpos.y = 0; /* right now at 0,0 */
241: data->curhot.x = data->curhot.y = 0; /* hot spot at 0,0 */
242:
243: /* initial cursor colormap: 0 is black, 1 is white */
244: data->curcmap_r[0] = data->curcmap_g[0] = data->curcmap_b[0] = 0;
245: data->curcmap_r[1] = data->curcmap_g[1] = data->curcmap_b[1] = 0xff;
246:
247: /* initial cursor data: 64x64 block of white. */
248: data->cursize.x = data->cursize.y = 64;
249: for (i = 0; i < 512; i++)
250: data->curimage[i] = data->curmask[i] = 0xff;
251:
252: /* Initial colormap: 0 is black, everything else is white */
253: data->cmap_r[0] = data->cmap_g[0] = data->cmap_b[0] = 0;
254: for (i = 0; i < 256; i++) {
255: data->cmap_r[i] = rasops_cmap[3*i + 0];
256: data->cmap_g[i] = rasops_cmap[3*i + 1];
257: data->cmap_b[i] = rasops_cmap[3*i + 2];
258: }
259:
260: bt485_update((void *)data);
261: }
262:
263: int
264: bt485_set_cmap(rc, cmapp)
265: struct ramdac_cookie *rc;
266: struct wsdisplay_cmap *cmapp;
267: {
268: struct bt485data *data = (struct bt485data *)rc;
269: u_int count, index;
270: int s, error;
271:
272: #ifdef DIAGNOSTIC
273: if (rc == NULL)
274: panic("bt485_set_cmap: rc");
275: if (cmapp == NULL)
276: panic("bt485_set_cmap: cmapp");
277: #endif
278: index = cmapp->index;
279: count = cmapp->count;
280:
281: if (index >= 256 || count > 256 - index)
282: return (EINVAL);
283:
284: s = spltty();
285:
286: if ((error = copyin(cmapp->red, &data->cmap_r[index], count)) != 0) {
287: splx(s);
288: return (error);
289: }
290: if ((error = copyin(cmapp->green, &data->cmap_g[index], count)) != 0) {
291: splx(s);
292: return (error);
293: }
294: if ((error = copyin(cmapp->blue, &data->cmap_b[index], count)) != 0) {
295: splx(s);
296: return (error);
297: }
298:
299: data->changed |= DATA_CMAP_CHANGED;
300:
301: data->ramdac_sched_update(data->cookie, bt485_update);
302: #ifdef __alpha__
303: alpha_mb();
304: #endif
305: splx(s);
306:
307: return (0);
308: }
309:
310: int
311: bt485_get_cmap(rc, cmapp)
312: struct ramdac_cookie *rc;
313: struct wsdisplay_cmap *cmapp;
314: {
315: struct bt485data *data = (struct bt485data *)rc;
316: u_int count, index;
317: int error;
318:
319: if (cmapp->index >= 256 || cmapp->count > 256 - cmapp->index)
320: return (EINVAL);
321:
322: count = cmapp->count;
323: index = cmapp->index;
324:
325: error = copyout(&data->cmap_r[index], cmapp->red, count);
326: if (error)
327: return (error);
328: error = copyout(&data->cmap_g[index], cmapp->green, count);
329: if (error)
330: return (error);
331: error = copyout(&data->cmap_b[index], cmapp->blue, count);
332: return (error);
333: }
334:
335: int
336: bt485_set_cursor(rc, cursorp)
337: struct ramdac_cookie *rc;
338: struct wsdisplay_cursor *cursorp;
339: {
340: struct bt485data *data = (struct bt485data *)rc;
341: u_int count, index;
342: int error;
343: int v, s;
344:
345: v = cursorp->which;
346:
347: /*
348: * For DOCMAP and DOSHAPE, verify that parameters are OK
349: * before we do anything that we can't recover from.
350: */
351: if (v & WSDISPLAY_CURSOR_DOCMAP) {
352: index = cursorp->cmap.index;
353: count = cursorp->cmap.count;
354: if (index >= 2 || count > 2 - index)
355: return (EINVAL);
356: }
357: if (v & WSDISPLAY_CURSOR_DOSHAPE) {
358: if ((u_int)cursorp->size.x > CURSOR_MAX_SIZE ||
359: (u_int)cursorp->size.y > CURSOR_MAX_SIZE)
360: return (EINVAL);
361: }
362:
363: if (v & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOCUR)) {
364: if (v & WSDISPLAY_CURSOR_DOPOS)
365: data->curpos = cursorp->pos;
366: if (v & WSDISPLAY_CURSOR_DOCUR)
367: data->curhot = cursorp->hot;
368: bt485_update_curpos(data);
369: }
370:
371: s = spltty();
372:
373: /* Parameters are OK; perform the requested operations. */
374: if (v & WSDISPLAY_CURSOR_DOCUR) {
375: data->curenb = cursorp->enable;
376: data->changed |= DATA_ENB_CHANGED;
377: }
378: if (v & WSDISPLAY_CURSOR_DOCMAP) {
379: index = cursorp->cmap.index;
380: count = cursorp->cmap.count;
381: if ((error = copyin(cursorp->cmap.red,
382: &data->curcmap_r[index], count)) != 0) {
383: splx(s);
384: return (error);
385: }
386: if ((error = copyin(cursorp->cmap.green,
387: &data->curcmap_g[index], count)) != 0) {
388: splx(s);
389: return (error);
390: }
391: if ((error = copyin(cursorp->cmap.blue,
392: &data->curcmap_b[index], count)) != 0) {
393: splx(s);
394: return (error);
395: }
396: data->changed |= DATA_CURCMAP_CHANGED;
397: }
398: if (v & WSDISPLAY_CURSOR_DOSHAPE) {
399: data->cursize = cursorp->size;
400: count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
401: bzero(data->curimage, sizeof data->curimage);
402: bzero(data->curmask, sizeof data->curmask);
403: if ((error = copyin(cursorp->image, data->curimage,
404: count)) != 0) {
405: splx(s);
406: return (error);
407: }
408: if ((error = copyin(cursorp->mask, data->curmask,
409: count)) != 0) {
410: splx(s);
411: return (error);
412: }
413: data->changed |= DATA_CURSHAPE_CHANGED;
414: }
415:
416: if (data->changed)
417: data->ramdac_sched_update(data->cookie, bt485_update);
418: splx(s);
419:
420: return (0);
421: }
422:
423: int
424: bt485_get_cursor(rc, cursorp)
425: struct ramdac_cookie *rc;
426: struct wsdisplay_cursor *cursorp;
427: {
428: struct bt485data *data = (struct bt485data *)rc;
429: int error, count;
430:
431: /* we return everything they want */
432: cursorp->which = WSDISPLAY_CURSOR_DOALL;
433:
434: cursorp->enable = data->curenb; /* DOCUR */
435: cursorp->pos = data->curpos; /* DOPOS */
436: cursorp->hot = data->curhot; /* DOHOT */
437:
438: cursorp->cmap.index = 0; /* DOCMAP */
439: cursorp->cmap.count = 2;
440: if (cursorp->cmap.red != NULL) {
441: error = copyout(data->curcmap_r, cursorp->cmap.red, 2);
442: if (error)
443: return (error);
444: }
445: if (cursorp->cmap.green != NULL) {
446: error = copyout(data->curcmap_g, cursorp->cmap.green, 2);
447: if (error)
448: return (error);
449: }
450: if (cursorp->cmap.blue != NULL) {
451: error = copyout(data->curcmap_b, cursorp->cmap.blue, 2);
452: if (error)
453: return (error);
454: }
455:
456: cursorp->size = data->cursize; /* DOSHAPE */
457: if (cursorp->image != NULL) {
458: count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
459: error = copyout(data->curimage, cursorp->image, count);
460: if (error)
461: return (error);
462: error = copyout(data->curmask, cursorp->mask, count);
463: if (error)
464: return (error);
465: }
466:
467: return (0);
468: }
469:
470: int
471: bt485_set_curpos(rc, curposp)
472: struct ramdac_cookie *rc;
473: struct wsdisplay_curpos *curposp;
474: {
475: struct bt485data *data = (struct bt485data *)rc;
476:
477: data->curpos = *curposp;
478: bt485_update_curpos(data);
479:
480: return (0);
481: }
482:
483: int
484: bt485_get_curpos(rc, curposp)
485: struct ramdac_cookie *rc;
486: struct wsdisplay_curpos *curposp;
487: {
488: struct bt485data *data = (struct bt485data *)rc;
489:
490: *curposp = data->curpos;
491: return (0);
492: }
493:
494: int
495: bt485_get_curmax(rc, curposp)
496: struct ramdac_cookie *rc;
497: struct wsdisplay_curpos *curposp;
498: {
499:
500: curposp->x = curposp->y = CURSOR_MAX_SIZE;
501: return (0);
502: }
503:
504: /*****************************************************************************/
505:
506: /*
507: * Internal functions.
508: */
509:
510: inline void
511: bt485_wr_i(data, ireg, val)
512: struct bt485data *data;
513: u_int8_t ireg;
514: u_int8_t val;
515: {
516: data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, ireg);
517: data->ramdac_wr(data->cookie, BT485_REG_EXTENDED, val);
518: }
519:
520: inline u_int8_t
521: bt485_rd_i(data, ireg)
522: struct bt485data *data;
523: u_int8_t ireg;
524: {
525: data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, ireg);
526: return (data->ramdac_rd(data->cookie, BT485_REG_EXTENDED));
527: }
528:
529: void
530: bt485_update(vp)
531: void *vp;
532: {
533: struct bt485data *data = vp;
534: u_int8_t regval;
535: int count, i, v;
536:
537: v = data->changed;
538: data->changed = 0;
539:
540: if (v & DATA_ENB_CHANGED) {
541: regval = data->ramdac_rd(data->cookie, BT485_REG_COMMAND_2);
542: if (data->curenb)
543: regval |= 0x01;
544: else
545: regval &= ~0x03;
546: data->ramdac_wr(data->cookie, BT485_REG_COMMAND_2, regval);
547: }
548:
549: if (v & DATA_CURCMAP_CHANGED) {
550: /* addr[9:0] assumed to be 0 */
551: /* set addr[7:0] to 1 */
552: data->ramdac_wr(data->cookie, BT485_REG_COC_WRADDR, 0x01);
553:
554: /* spit out the cursor data */
555: for (i = 0; i < 2; i++) {
556: data->ramdac_wr(data->cookie, BT485_REG_COCDATA,
557: data->curcmap_r[i]);
558: data->ramdac_wr(data->cookie, BT485_REG_COCDATA,
559: data->curcmap_g[i]);
560: data->ramdac_wr(data->cookie, BT485_REG_COCDATA,
561: data->curcmap_b[i]);
562: }
563: }
564:
565: if (v & DATA_CURSHAPE_CHANGED) {
566: count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
567:
568: /*
569: * Write the cursor image data:
570: * set addr[9:8] to 0,
571: * set addr[7:0] to 0,
572: * spit it all out.
573: */
574: regval = bt485_rd_i(data, BT485_IREG_COMMAND_3);
575: regval &= ~0x03;
576: bt485_wr_i(data, BT485_IREG_COMMAND_3, regval);
577: data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, 0);
578: for (i = 0; i < count; i++)
579: data->ramdac_wr(data->cookie, BT485_REG_CURSOR_RAM,
580: data->curimage[i]);
581:
582: /*
583: * Write the cursor mask data:
584: * set addr[9:8] to 2,
585: * set addr[7:0] to 0,
586: * spit it all out.
587: */
588: regval = bt485_rd_i(data, BT485_IREG_COMMAND_3);
589: regval &= ~0x03; regval |= 0x02;
590: bt485_wr_i(data, BT485_IREG_COMMAND_3, regval);
591: data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, 0);
592: for (i = 0; i < count; i++)
593: data->ramdac_wr(data->cookie, BT485_REG_CURSOR_RAM,
594: data->curmask[i]);
595:
596: /* set addr[9:0] back to 0 */
597: regval = bt485_rd_i(data, BT485_IREG_COMMAND_3);
598: regval &= ~0x03;
599: bt485_wr_i(data, BT485_IREG_COMMAND_3, regval);
600: }
601:
602: if (v & DATA_CMAP_CHANGED) {
603: /* addr[9:0] assumed to be 0 */
604: /* set addr[7:0] to 0 */
605: data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, 0x00);
606:
607: /* spit out the cursor data */
608: for (i = 0; i < 256; i++) {
609: data->ramdac_wr(data->cookie, BT485_REG_PALETTE,
610: data->cmap_r[i]);
611: data->ramdac_wr(data->cookie, BT485_REG_PALETTE,
612: data->cmap_g[i]);
613: data->ramdac_wr(data->cookie, BT485_REG_PALETTE,
614: data->cmap_b[i]);
615: }
616: }
617: }
618:
619: void
620: bt485_update_curpos(data)
621: struct bt485data *data;
622: {
623: void *cookie = data->cookie;
624: int s, x, y;
625:
626: s = spltty();
627:
628: x = data->curpos.x + CURSOR_MAX_SIZE - data->curhot.x;
629: y = data->curpos.y + CURSOR_MAX_SIZE - data->curhot.y;
630: data->ramdac_wr(cookie, BT485_REG_CURSOR_X_LOW, x & 0xff);
631: data->ramdac_wr(cookie, BT485_REG_CURSOR_X_HIGH, (x >> 8) & 0x0f);
632: data->ramdac_wr(cookie, BT485_REG_CURSOR_Y_LOW, y & 0xff);
633: data->ramdac_wr(cookie, BT485_REG_CURSOR_Y_HIGH, (y >> 8) & 0x0f);
634:
635: splx(s);
636: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to bt485.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic