Annotation of sys/dev/ic/ibm561.c, Revision 1.1.1.1
1.1 nbrk 1: /* $NetBSD: ibm561.c,v 1.1 2001/12/12 07:46:48 elric Exp $ */
2: /* $OpenBSD: ibm561.c,v 1.4 2006/07/16 21:50:58 miod Exp $ */
3:
4: /*-
5: * Copyright (c) 2001 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Roland C. Dowdeswell of Ponte, Inc.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: #include <sys/param.h>
41: #include <sys/systm.h>
42: #include <sys/device.h>
43: #include <sys/buf.h>
44: #include <sys/kernel.h>
45: #include <sys/malloc.h>
46:
47: #include <uvm/uvm_extern.h>
48:
49: #include <dev/pci/pcivar.h>
50: #include <dev/ic/ibm561reg.h>
51: #include <dev/ic/ibm561var.h>
52: #include <dev/ic/ramdac.h>
53:
54: #include <dev/wscons/wsconsio.h>
55:
56: /*
57: * Functions exported via the RAMDAC configuration table.
58: */
59: void ibm561_init(struct ramdac_cookie *);
60: int ibm561_set_cmap(struct ramdac_cookie *,
61: struct wsdisplay_cmap *);
62: int ibm561_get_cmap(struct ramdac_cookie *,
63: struct wsdisplay_cmap *);
64: int ibm561_set_cursor(struct ramdac_cookie *,
65: struct wsdisplay_cursor *);
66: int ibm561_get_cursor(struct ramdac_cookie *,
67: struct wsdisplay_cursor *);
68: int ibm561_set_curpos(struct ramdac_cookie *,
69: struct wsdisplay_curpos *);
70: int ibm561_get_curpos(struct ramdac_cookie *,
71: struct wsdisplay_curpos *);
72: int ibm561_get_curmax(struct ramdac_cookie *,
73: struct wsdisplay_curpos *);
74: int ibm561_set_dotclock(struct ramdac_cookie *,
75: unsigned);
76:
77: /* XXX const */
78: struct ramdac_funcs ibm561_funcsstruct = {
79: "IBM561",
80: ibm561_register,
81: ibm561_init,
82: ibm561_set_cmap,
83: ibm561_get_cmap,
84: ibm561_set_cursor,
85: ibm561_get_cursor,
86: ibm561_set_curpos,
87: ibm561_get_curpos,
88: ibm561_get_curmax,
89: NULL, /* check_curcmap; not needed */
90: NULL, /* set_curcmap; not needed */
91: NULL, /* get_curcmap; not needed */
92: ibm561_set_dotclock,
93: };
94:
95: /*
96: * Private data.
97: */
98: struct ibm561data {
99: void *cookie;
100:
101: int (*ramdac_sched_update)(void *, void (*)(void *));
102: void (*ramdac_wr)(void *, u_int, u_int8_t);
103: u_int8_t (*ramdac_rd)(void *, u_int);
104:
105: #define CHANGED_CURCMAP 0x0001 /* cursor cmap */
106: #define CHANGED_CMAP 0x0002 /* color map */
107: #define CHANGED_WTYPE 0x0004 /* window types */
108: #define CHANGED_DOTCLOCK 0x0008 /* dot clock */
109: #define CHANGED_ALL 0x000f /* or of all above */
110: u_int8_t changed;
111:
112: /* dotclock parameters */
113: u_int8_t vco_div;
114: u_int8_t pll_ref;
115: u_int8_t div_dotclock;
116:
117: /* colormaps et al. */
118: u_int8_t curcmap_r[2];
119: u_int8_t curcmap_g[2];
120: u_int8_t curcmap_b[2];
121:
122: u_int8_t cmap_r[IBM561_NCMAP_ENTRIES];
123: u_int8_t cmap_g[IBM561_NCMAP_ENTRIES];
124: u_int8_t cmap_b[IBM561_NCMAP_ENTRIES];
125:
126: u_int16_t gamma_r[IBM561_NGAMMA_ENTRIES];
127: u_int16_t gamma_g[IBM561_NGAMMA_ENTRIES];
128: u_int16_t gamma_b[IBM561_NGAMMA_ENTRIES];
129:
130: u_int16_t wtype[IBM561_NWTYPES];
131: };
132:
133: /*
134: * private functions
135: */
136: void ibm561_update(void *);
137: static void ibm561_load_cmap(struct ibm561data *);
138: static void ibm561_load_dotclock(struct ibm561data *);
139: static void ibm561_regbegin(struct ibm561data *, u_int16_t);
140: static void ibm561_regcont(struct ibm561data *, u_int16_t, u_int8_t);
141: static void ibm561_regcont10bit(struct ibm561data *, u_int16_t, u_int16_t);
142: static void ibm561_regwr(struct ibm561data *, u_int16_t, u_int8_t);
143:
144: struct ramdac_funcs *
145: ibm561_funcs(void)
146: {
147: return &ibm561_funcsstruct;
148: }
149:
150: struct ibm561data ibm561_console_data;
151:
152: struct ramdac_cookie *
153: ibm561_register(v, sched_update, wr, rd)
154: void *v;
155: int (*sched_update)(void *, void (*)(void *));
156: void (*wr)(void *, u_int, u_int8_t);
157: u_int8_t (*rd)(void *, u_int);
158: {
159: struct ibm561data *data;
160:
161: if (ibm561_console_data.cookie == NULL) {
162: data = malloc(sizeof *data, M_DEVBUF, M_WAITOK);
163: bzero(data, sizeof *data);
164: } else
165: data = &ibm561_console_data;
166: data->cookie = v;
167: data->ramdac_sched_update = sched_update;
168: data->ramdac_wr = wr;
169: data->ramdac_rd = rd;
170: return (struct ramdac_cookie *)data;
171: }
172:
173: /*
174: * This function exists solely to provide a means to init
175: * the RAMDAC without first registering. It is useful for
176: * initializing the console early on.
177: */
178:
179: void
180: ibm561_cninit(v, sched_update, wr, rd, dotclock)
181: void *v;
182: int (*sched_update)(void *, void (*)(void *));
183: void (*wr)(void *, u_int, u_int8_t);
184: u_int8_t (*rd)(void *, u_int);
185: u_int dotclock;
186: {
187: struct ibm561data *data = &ibm561_console_data;
188: data->cookie = v;
189: data->ramdac_sched_update = sched_update;
190: data->ramdac_wr = wr;
191: data->ramdac_rd = rd;
192: ibm561_set_dotclock((struct ramdac_cookie *)data, dotclock);
193: ibm561_init((struct ramdac_cookie *)data);
194: }
195:
196: void
197: ibm561_init(rc)
198: struct ramdac_cookie *rc;
199: {
200: struct ibm561data *data = (struct ibm561data *)rc;
201: int i;
202:
203: /* XXX this is _essential_ */
204:
205: ibm561_load_dotclock(data);
206:
207: /* XXXrcd: bunch of magic of which I have no current clue */
208: ibm561_regwr(data, IBM561_CONFIG_REG1, 0x2a);
209: ibm561_regwr(data, IBM561_CONFIG_REG3, 0x41);
210: ibm561_regwr(data, IBM561_CONFIG_REG4, 0x20);
211:
212: /* initialize the card a bit */
213: ibm561_regwr(data, IBM561_SYNC_CNTL, 0x1);
214: ibm561_regwr(data, IBM561_CONFIG_REG2, 0x19);
215:
216: ibm561_regwr(data, IBM561_CONFIG_REG1, 0x2a);
217: ibm561_regwr(data, IBM561_CONFIG_REG4, 0x20);
218:
219: ibm561_regbegin(data, IBM561_WAT_SEG_REG);
220: ibm561_regcont(data, IBM561_CMD, 0x00);
221: ibm561_regcont(data, IBM561_CMD, 0x00);
222: ibm561_regcont(data, IBM561_CMD, 0x00);
223: ibm561_regcont(data, IBM561_CMD, 0x00);
224: ibm561_regbegin(data, IBM561_CHROMAKEY0);
225: ibm561_regcont(data, IBM561_CMD, 0x00);
226: ibm561_regcont(data, IBM561_CMD, 0x00);
227: ibm561_regcont(data, IBM561_CMD, 0x00);
228: ibm561_regcont(data, IBM561_CMD, 0x00);
229:
230: ibm561_regwr(data, IBM561_CURS_CNTL_REG, 0x00); /* XXX off? */
231:
232: /* cursor `hot spot' registers */
233: ibm561_regbegin(data, IBM561_HOTSPOT_REG);
234: ibm561_regcont(data, IBM561_CMD, 0x00);
235: ibm561_regcont(data, IBM561_CMD, 0x00);
236: ibm561_regcont(data, IBM561_CMD, 0xff);
237: ibm561_regcont(data, IBM561_CMD, 0x00);
238: ibm561_regcont(data, IBM561_CMD, 0xff);
239: ibm561_regcont(data, IBM561_CMD, 0x00);
240:
241: /* VRAM Mask Registers (diagnostics) */
242: ibm561_regbegin(data, IBM561_VRAM_MASK_REG);
243: ibm561_regcont(data, IBM561_CMD, 0xff);
244: ibm561_regcont(data, IBM561_CMD, 0xff);
245: ibm561_regcont(data, IBM561_CMD, 0xff);
246: ibm561_regcont(data, IBM561_CMD, 0xff);
247: ibm561_regcont(data, IBM561_CMD, 0xff);
248: ibm561_regcont(data, IBM561_CMD, 0xff);
249: ibm561_regcont(data, IBM561_CMD, 0xff);
250:
251: /* let's set up some decent default colour maps and gammas */
252: for (i=0; i < IBM561_NCMAP_ENTRIES; i++)
253: data->cmap_r[i] = data->cmap_g[i] = data->cmap_b[i] = 0xff;
254: data->cmap_r[0] = data->cmap_g[0] = data->cmap_b[0] = 0x00;
255: data->cmap_r[256] = data->cmap_g[256] = data->cmap_b[256] = 0x00;
256: data->cmap_r[512] = data->cmap_g[512] = data->cmap_b[512] = 0x00;
257: data->cmap_r[768] = data->cmap_g[768] = data->cmap_b[768] = 0x00;
258:
259: data->gamma_r[0] = data->gamma_g[0] = data->gamma_b[0] = 0x00;
260: for (i=0; i < IBM561_NGAMMA_ENTRIES; i++)
261: data->gamma_r[i] = data->gamma_g[i] = data->gamma_b[i] = 0xff;
262:
263: for (i=0; i < IBM561_NWTYPES; i++)
264: data->wtype[i] = 0x0036;
265: data->wtype[1] = 0x0028;
266:
267: /* the last step: */
268: data->changed = CHANGED_ALL;
269: data->ramdac_sched_update(data->cookie, ibm561_update);
270: }
271:
272: int
273: ibm561_set_cmap(rc, cmapp)
274: struct ramdac_cookie *rc;
275: struct wsdisplay_cmap *cmapp;
276: {
277: struct ibm561data *data = (struct ibm561data *)rc;
278: u_int count, index;
279: int error;
280: int s;
281:
282: index = cmapp->index;
283: count = cmapp->count;
284:
285: if (index >= IBM561_NCMAP_ENTRIES ||
286: count > IBM561_NCMAP_ENTRIES - index)
287: return (EINVAL);
288:
289: s = spltty();
290: if ((error = copyin(cmapp->red, &data->cmap_r[index], count)) != 0) {
291: splx(s);
292: return (error);
293: }
294: if ((error = copyin(cmapp->green, &data->cmap_g[index], count)) != 0) {
295: splx(s);
296: return (error);
297: }
298: if ((error = copyin(cmapp->blue, &data->cmap_b[index], count)) != 0) {
299: splx(s);
300: return (error);
301: }
302: data->changed |= CHANGED_CMAP;
303: data->ramdac_sched_update(data->cookie, ibm561_update);
304: splx(s);
305: return (0);
306: }
307:
308: int
309: ibm561_get_cmap(rc, cmapp)
310: struct ramdac_cookie *rc;
311: struct wsdisplay_cmap *cmapp;
312: {
313: struct ibm561data *data = (struct ibm561data *)rc;
314: u_int count, index;
315: int error;
316:
317: if (cmapp->index >= IBM561_NCMAP_ENTRIES ||
318: cmapp->count > IBM561_NCMAP_ENTRIES - cmapp->index)
319: return (EINVAL);
320: count = cmapp->count;
321: index = cmapp->index;
322: error = copyout(&data->cmap_r[index], cmapp->red, count);
323: if (error)
324: return (error);
325: error = copyout(&data->cmap_g[index], cmapp->green, count);
326: if (error)
327: return (error);
328: error = copyout(&data->cmap_b[index], cmapp->blue, count);
329: return (error);
330: }
331:
332: /*
333: * XXX:
334: * I am leaving these functions returning EINVAL, as they are
335: * not strictly necessary for the correct functioning of the
336: * card and in fact are not used on the other TGA variants, except
337: * they are exported via ioctl(2) to userland, which does not in
338: * fact use them.
339: */
340:
341: int
342: ibm561_set_cursor(rc, cursorp)
343: struct ramdac_cookie *rc;
344: struct wsdisplay_cursor *cursorp;
345: {
346: return EINVAL;
347: }
348:
349: int
350: ibm561_get_cursor(rc, cursorp)
351: struct ramdac_cookie *rc;
352: struct wsdisplay_cursor *cursorp;
353: {
354: return EINVAL;
355: }
356:
357: int
358: ibm561_set_curpos(rc, curposp)
359: struct ramdac_cookie *rc;
360: struct wsdisplay_curpos *curposp;
361: {
362: return EINVAL;
363: }
364:
365: int
366: ibm561_get_curpos(rc, curposp)
367: struct ramdac_cookie *rc;
368: struct wsdisplay_curpos *curposp;
369: {
370: return EINVAL;
371: }
372:
373: int
374: ibm561_get_curmax(rc, curposp)
375: struct ramdac_cookie *rc;
376: struct wsdisplay_curpos *curposp;
377: {
378: return EINVAL;
379: }
380:
381: int
382: ibm561_set_dotclock(rc, dotclock)
383: struct ramdac_cookie *rc;
384: unsigned dotclock;
385: {
386: struct ibm561data *data = (struct ibm561data *)rc;
387:
388: /* XXXrcd: a couple of these are a little hazy, vis a vis
389: * check 175MHz and 202MHz, which are wrong...
390: */
391: switch (dotclock) {
392: case 25175000: data->vco_div = 0x3e; data->pll_ref = 0x09; break;
393: case 31500000: data->vco_div = 0x17; data->pll_ref = 0x05; break;
394: case 40000000: data->vco_div = 0x42; data->pll_ref = 0x06; break;
395: case 50000000: data->vco_div = 0x45; data->pll_ref = 0x05; break;
396: case 65000000: data->vco_div = 0xac; data->pll_ref = 0x0c; break;
397: case 69000000: data->vco_div = 0xa9; data->pll_ref = 0x0b; break;
398: case 74000000: data->vco_div = 0x9c; data->pll_ref = 0x09; break;
399: case 75000000: data->vco_div = 0x93; data->pll_ref = 0x08; break;
400: case 103994000: data->vco_div = 0x96; data->pll_ref = 0x06; break;
401: case 108180000: data->vco_div = 0xb8; data->pll_ref = 0x08; break;
402: case 110000000: data->vco_div = 0xba; data->pll_ref = 0x08; break;
403: case 119840000: data->vco_div = 0x82; data->pll_ref = 0x04; break;
404: case 130808000: data->vco_div = 0xc8; data->pll_ref = 0x08; break;
405: case 135000000: data->vco_div = 0xc1; data->pll_ref = 0x07; break;
406: case 175000000: data->vco_div = 0xe2; data->pll_ref = 0x07; break;
407: case 202500000: data->vco_div = 0xe2; data->pll_ref = 0x07; break;
408: default:
409: return EINVAL;
410: }
411:
412: data->div_dotclock = 0xb0;
413: data->changed |= CHANGED_DOTCLOCK;
414: return 0;
415: }
416:
417: /*
418: * Internal Functions
419: */
420:
421: void
422: ibm561_update(vp)
423: void *vp;
424: {
425: struct ibm561data *data = (struct ibm561data *)vp;
426: int i;
427:
428: /* XXX see comment above ibm561_cninit() */
429: if (!data)
430: data = &ibm561_console_data;
431:
432: if (data->changed & CHANGED_WTYPE) {
433: ibm561_regbegin(data, IBM561_FB_WINTYPE);
434: for (i=0; i < IBM561_NWTYPES; i++)
435: ibm561_regcont10bit(data, IBM561_CMD_FB_WAT, data->wtype[i]);
436:
437: /* XXXrcd: quick hack here for AUX FB table */
438: ibm561_regbegin(data, IBM561_AUXFB_WINTYPE);
439: for (i=0; i < IBM561_NWTYPES; i++)
440: ibm561_regcont(data, IBM561_CMD, 0x04);
441:
442: /* XXXrcd: quick hack here for OL WAT table */
443: ibm561_regbegin(data, IBM561_OL_WINTYPE);
444: for (i=0; i < IBM561_NWTYPES; i++)
445: ibm561_regcont10bit(data, IBM561_CMD_FB_WAT, 0x0231);
446:
447: /* XXXrcd: quick hack here for AUX OL WAT table */
448: ibm561_regbegin(data, IBM561_AUXOL_WINTYPE);
449: for (i=0; i < IBM561_NWTYPES; i++)
450: ibm561_regcont(data, IBM561_CMD, 0x0c);
451: }
452:
453: if (data->changed & CHANGED_CMAP)
454: ibm561_load_cmap(data);
455:
456: /* XXX: I am not sure in what situations it is safe to
457: * change the dotclock---hope this is good.
458: */
459: if (data->changed & CHANGED_DOTCLOCK)
460: ibm561_load_dotclock(data);
461: }
462:
463: static void
464: ibm561_load_cmap(struct ibm561data *data)
465: {
466: int i;
467:
468: ibm561_regbegin(data, IBM561_CMAP_TABLE);
469: for (i=0; i < IBM561_NCMAP_ENTRIES; i++) {
470: ibm561_regcont(data, IBM561_CMD_CMAP, data->cmap_r[i]);
471: ibm561_regcont(data, IBM561_CMD_CMAP, data->cmap_g[i]);
472: ibm561_regcont(data, IBM561_CMD_CMAP, data->cmap_b[i]);
473: }
474:
475: ibm561_regbegin(data, IBM561_RED_GAMMA_TABLE);
476: for (i=0; i < 256; i++)
477: ibm561_regcont10bit(data, IBM561_CMD_GAMMA, data->gamma_r[i]);
478:
479: ibm561_regbegin(data, IBM561_GREEN_GAMMA_TABLE);
480: for (i=1; i < 256; i++)
481: ibm561_regcont10bit(data, IBM561_CMD_GAMMA, data->gamma_g[i]);
482:
483: ibm561_regbegin(data, IBM561_BLUE_GAMMA_TABLE);
484: for (i=1; i < 256; i++)
485: ibm561_regcont10bit(data, IBM561_CMD_GAMMA, data->gamma_b[i]);
486:
487: }
488:
489: static void
490: ibm561_load_dotclock(struct ibm561data *data)
491: {
492: /* XXX
493: * we should probably be more pro-active here, but it shouldn't
494: * actually happen...
495: */
496: if (!data->vco_div || !data->pll_ref || ! data->div_dotclock) {
497: panic("ibm561_load_dotclock: called uninitialized");
498: }
499:
500: ibm561_regwr(data, IBM561_PLL_VCO_DIV, data->vco_div);
501: ibm561_regwr(data, IBM561_PLL_REF_REG, data->pll_ref);
502: ibm561_regwr(data, IBM561_DIV_DOTCLCK, data->div_dotclock);
503: }
504:
505: static void
506: ibm561_regcont10bit(struct ibm561data *data, u_int16_t reg, u_int16_t val)
507: {
508: data->ramdac_wr(data->cookie, IBM561_CMD_GAMMA, (val >> 2) & 0xff);
509: data->ramdac_wr(data->cookie, IBM561_CMD_GAMMA, (val & 0x3) << 6);
510: }
511:
512: static void
513: ibm561_regbegin(struct ibm561data *data, u_int16_t reg)
514: {
515: data->ramdac_wr(data->cookie, IBM561_ADDR_LOW, reg & 0xff);
516: data->ramdac_wr(data->cookie, IBM561_ADDR_HIGH, (reg >> 8) & 0xff);
517: }
518:
519: static void
520: ibm561_regcont(struct ibm561data *data, u_int16_t reg, u_int8_t val)
521: {
522: data->ramdac_wr(data->cookie, reg, val);
523: }
524:
525: static void
526: ibm561_regwr(struct ibm561data *data, u_int16_t reg, u_int8_t val)
527: {
528: ibm561_regbegin(data, reg);
529: ibm561_regcont(data, IBM561_CMD, val);
530: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ibm561.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic