Annotation of sys/dev/ic/bt463.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: bt463.c,v 1.10 2002/11/09 22:51:48 miod Exp $ */
2: /* $NetBSD: bt463.c,v 1.2 2000/06/13 17:21:06 nathanw Exp $ */
3:
4: /*-
5: * Copyright (c) 1998 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
10: * NASA Ames Research Center.
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: * 3. All advertising materials mentioning features or use of this software
21: * must display the following acknowledgement:
22: * This product includes software developed by the NetBSD
23: * Foundation, Inc. and its contributors.
24: * 4. Neither the name of The NetBSD Foundation nor the names of its
25: * contributors may be used to endorse or promote products derived
26: * from this software without specific prior written permission.
27: *
28: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
29: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
30: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
31: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
32: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
36: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38: * POSSIBILITY OF SUCH DAMAGE.
39: */
40:
41: /*
42: * Copyright (c) 1995, 1996 Carnegie-Mellon University.
43: * All rights reserved.
44: *
45: * Author: Chris G. Demetriou
46: *
47: * Permission to use, copy, modify and distribute this software and
48: * its documentation is hereby granted, provided that both the copyright
49: * notice and this permission notice appear in all copies of the
50: * software, derivative works or modified versions, and any portions
51: * thereof, and that both notices appear in supporting documentation.
52: *
53: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
54: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
55: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
56: *
57: * Carnegie Mellon requests users of this software to return to
58: *
59: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
60: * School of Computer Science
61: * Carnegie Mellon University
62: * Pittsburgh PA 15213-3890
63: *
64: * any improvements or extensions that they make and grant Carnegie the
65: * rights to redistribute these changes.
66: */
67:
68: /* This code was derived from and originally located in sys/dev/pci/
69: * NetBSD: tga_bt463.c,v 1.5 2000/03/04 10:27:59 elric Exp
70: */
71:
72: #include <sys/param.h>
73: #include <sys/systm.h>
74: #include <sys/device.h>
75: #include <sys/buf.h>
76: #include <sys/kernel.h>
77: #include <sys/malloc.h>
78:
79: #include <uvm/uvm_extern.h>
80:
81: #include <dev/pci/pcivar.h>
82: #include <dev/pci/tgareg.h>
83: #include <dev/pci/tgavar.h>
84: #include <dev/ic/bt463reg.h>
85: #include <dev/ic/bt463var.h>
86:
87: #include <dev/wscons/wsconsio.h>
88:
89: /*
90: * Functions exported via the RAMDAC configuration table.
91: */
92: void bt463_init(struct ramdac_cookie *);
93: int bt463_set_cmap(struct ramdac_cookie *,
94: struct wsdisplay_cmap *);
95: int bt463_get_cmap(struct ramdac_cookie *,
96: struct wsdisplay_cmap *);
97: int bt463_set_cursor(struct ramdac_cookie *,
98: struct wsdisplay_cursor *);
99: int bt463_get_cursor(struct ramdac_cookie *,
100: struct wsdisplay_cursor *);
101: int bt463_set_curpos(struct ramdac_cookie *,
102: struct wsdisplay_curpos *);
103: int bt463_get_curpos(struct ramdac_cookie *,
104: struct wsdisplay_curpos *);
105: int bt463_get_curmax(struct ramdac_cookie *,
106: struct wsdisplay_curpos *);
107: int bt463_check_curcmap(struct ramdac_cookie *,
108: struct wsdisplay_cursor *cursorp);
109: void bt463_set_curcmap(struct ramdac_cookie *,
110: struct wsdisplay_cursor *cursorp);
111: int bt463_get_curcmap(struct ramdac_cookie *,
112: struct wsdisplay_cursor *cursorp);
113:
114: #ifdef BT463_DEBUG
115: int bt463_store(void *);
116: int bt463_debug(void *);
117: int bt463_readback(void *);
118: void bt463_copyback(void *);
119: #endif
120:
121: struct ramdac_funcs bt463_funcsstruct = {
122: "Bt463",
123: bt463_register,
124: bt463_init,
125: bt463_set_cmap,
126: bt463_get_cmap,
127: bt463_set_cursor,
128: bt463_get_cursor,
129: bt463_set_curpos,
130: bt463_get_curpos,
131: bt463_get_curmax,
132: bt463_check_curcmap,
133: bt463_set_curcmap,
134: bt463_get_curcmap,
135: NULL,
136: };
137:
138: /*
139: * Private data.
140: */
141: struct bt463data {
142: void *cookie; /* This is what is passed
143: * around, and is probably
144: * struct tga_devconfig *
145: */
146:
147: int (*ramdac_sched_update)(void *, void (*)(void *));
148: void (*ramdac_wr)(void *, u_int, u_int8_t);
149: u_int8_t (*ramdac_rd)(void *, u_int);
150:
151: int changed; /* what changed; see below */
152: char curcmap_r[2]; /* cursor colormap */
153: char curcmap_g[2];
154: char curcmap_b[2];
155: char cmap_r[BT463_NCMAP_ENTRIES]; /* colormap */
156: char cmap_g[BT463_NCMAP_ENTRIES];
157: char cmap_b[BT463_NCMAP_ENTRIES];
158: int window_type[16]; /* 16 24-bit window type table entries */
159: };
160:
161: /* When we're doing console initialization, there's no
162: * way to get our cookie back to the video card's softc
163: * before we call sched_update. So we stash it here,
164: * and bt463_update will look for it here first.
165: */
166: static struct bt463data *console_data;
167:
168:
169: #define BTWREG(data, addr, val) do { bt463_wraddr((data), (addr)); \
170: (data)->ramdac_wr((data)->cookie, BT463_REG_IREG_DATA, (val)); } while (0)
171: #define BTWNREG(data, val) (data)->ramdac_wr((data)->cookie, \
172: BT463_REG_IREG_DATA, (val))
173: #define BTRREG(data, addr) (bt463_wraddr((data), (addr)), \
174: (data)->ramdac_rd((data)->cookie, BT463_REG_IREG_DATA))
175: #define BTRNREG(data) ((data)->ramdac_rd((data)->cookie, BT463_REG_IREG_DATA))
176:
177: #define DATA_CURCMAP_CHANGED 0x01 /* cursor colormap changed */
178: #define DATA_CMAP_CHANGED 0x02 /* colormap changed */
179: #define DATA_WTYPE_CHANGED 0x04 /* window type table changed */
180: #define DATA_ALL_CHANGED 0x07
181:
182: /*
183: * Internal functions.
184: */
185: inline void bt463_wraddr(struct bt463data *, u_int16_t);
186:
187: void bt463_update(void *);
188:
189:
190: /*****************************************************************************/
191:
192: /*
193: * Functions exported via the RAMDAC configuration table.
194: */
195:
196: struct ramdac_funcs *
197: bt463_funcs(void)
198: {
199: return &bt463_funcsstruct;
200: }
201:
202: struct ramdac_cookie *
203: bt463_register(v, sched_update, wr, rd)
204: void *v;
205: int (*sched_update)(void *, void (*)(void *));
206: void (*wr)(void *, u_int, u_int8_t);
207: u_int8_t (*rd)(void *, u_int);
208: {
209: struct bt463data *data;
210: /*
211: * XXX -- comment out of date. rcd.
212: * If we should allocate a new private info struct, do so.
213: * Otherwise, use the one we have (if it's there), or
214: * use the temporary one on the stack.
215: */
216: data = malloc(sizeof *data, M_DEVBUF, M_WAITOK);
217: /* XXX -- if !data */
218: data->cookie = v;
219: data->ramdac_sched_update = sched_update;
220: data->ramdac_wr = wr;
221: data->ramdac_rd = rd;
222: return (struct ramdac_cookie *)data;
223: }
224:
225: /*
226: * This function exists solely to provide a means to init
227: * the RAMDAC without first registering. It is useful for
228: * initializing the console early on.
229: */
230: void
231: bt463_cninit(v, sched_update, wr, rd)
232: void *v;
233: int (*sched_update)(void *, void (*)(void *));
234: void (*wr)(void *, u_int, u_int8_t);
235: u_int8_t (*rd)(void *, u_int);
236: {
237: struct bt463data tmp, *data = &tmp;
238: data->cookie = v;
239: data->ramdac_sched_update = sched_update;
240: data->ramdac_wr = wr;
241: data->ramdac_rd = rd;
242: /* Set up console_data so that when bt463_update is called back,
243: * it can use the right information.
244: */
245: console_data = data;
246: bt463_init((struct ramdac_cookie *)data);
247: console_data = NULL;
248: }
249:
250: void
251: bt463_init(rc)
252: struct ramdac_cookie *rc;
253: {
254: struct bt463data *data = (struct bt463data *)rc;
255:
256: int i;
257:
258: /*
259: * Init the BT463 for normal operation.
260: */
261:
262:
263: /*
264: * Setup:
265: * reg 0: 4:1 multiplexing, 25/75 blink.
266: * reg 1: Overlay mapping: mapped to common palette,
267: * 14 window type entries, 24-plane configuration mode,
268: * 4 overlay planes, underlays disabled, no cursor.
269: * reg 2: sync-on-green enabled, pedestal enabled.
270: */
271:
272: BTWREG(data, BT463_IREG_COMMAND_0, 0x40);
273: BTWREG(data, BT463_IREG_COMMAND_1, 0x48);
274: BTWREG(data, BT463_IREG_COMMAND_2, 0xC0);
275:
276: /*
277: * Initialize the read mask.
278: */
279: bt463_wraddr(data, BT463_IREG_READ_MASK_P0_P7);
280: for (i = 0; i < 4; i++)
281: BTWNREG(data, 0xff);
282:
283: /*
284: * Initialize the blink mask.
285: */
286: bt463_wraddr(data, BT463_IREG_BLINK_MASK_P0_P7);
287: for (i = 0; i < 4; i++)
288: BTWNREG(data, 0);
289:
290:
291: /*
292: * Clear test register
293: */
294: BTWREG(data, BT463_IREG_TEST, 0);
295:
296: /*
297: * Initalize the RAMDAC info struct to hold all of our
298: * data, and fill it in.
299: */
300: data->changed = DATA_ALL_CHANGED;
301:
302: /* initial cursor colormap: 0 is black, 1 is white */
303: data->curcmap_r[0] = data->curcmap_g[0] = data->curcmap_b[0] = 0;
304: data->curcmap_r[1] = data->curcmap_g[1] = data->curcmap_b[1] = 0xff;
305:
306: /* Initial colormap: 0 is black, everything else is white */
307: data->cmap_r[0] = data->cmap_g[0] = data->cmap_b[0] = 0;
308: for (i = 1; i < 256; i++) {
309: data->cmap_r[i] = rasops_cmap[3*i + 0];
310: data->cmap_g[i] = rasops_cmap[3*i + 1];
311: data->cmap_b[i] = rasops_cmap[3*i + 2];
312: }
313:
314: /* Initialize the window type table:
315: *
316: * Entry 0: 24-plane truecolor, overlays enabled, bypassed.
317: *
318: * Lookup table bypass: yes ( 1 << 23 & 0x800000) 800000
319: * Colormap address: 0x000 (0x000 << 17 & 0x7e0000) 0
320: * Overlay mask: 0xf ( 0xf << 13 & 0x01e000) 1e000
321: * Overlay location: P<27:24> ( 0 << 12 & 0x001000) 0
322: * Display mode: Truecolor ( 0 << 9 & 0x000e00) 000
323: * Number of planes: 8 ( 8 << 5 & 0x0001e0) 100
324: * Plane shift: 0 ( 0 << 0 & 0x00001f) 0
325: * --------
326: * 0x81e100
327: */
328: data->window_type[0] = 0x81e100;
329:
330: /* Entry 1: 8-plane pseudocolor in the bottom 8 bits,
331: * overlays enabled, colormap starting at 0.
332: *
333: * Lookup table bypass: no ( 0 << 23 & 0x800000) 0
334: * Colormap address: 0x000 (0x000 << 17 & 0x7e0000) 0
335: * Overlay mask: 0xf ( 0xf << 13 & 0x01e000) 0x1e000
336: * Overlay location: P<27:24> ( 0 << 12 & 0x001000) 0
337: * Display mode: Pseudocolor ( 1 << 9 & 0x000e00) 0x200
338: * Number of planes: 8 ( 8 << 5 & 0x0001e0) 0x100
339: * Plane shift: 16 ( 0x10 << 0 & 0x00001f) 10
340: * --------
341: * 0x01e310
342: */
343: data->window_type[1] = 0x01e310;
344:
345: /* The colormap interface to the world only supports one colormap,
346: * so having an entry for the 'alternate' colormap in the bt463
347: * probably isn't useful.
348: */
349:
350: /* Fill the remaining table entries with clones of entry 0 until we
351: * figure out a better use for them.
352: */
353:
354: for (i = 2; i < BT463_NWTYPE_ENTRIES; i++) {
355: data->window_type[i] = 0x81e100;
356: }
357:
358: data->ramdac_sched_update(data->cookie, bt463_update);
359:
360: }
361:
362: int
363: bt463_set_cmap(rc, cmapp)
364: struct ramdac_cookie *rc;
365: struct wsdisplay_cmap *cmapp;
366: {
367: struct bt463data *data = (struct bt463data *)rc;
368: u_int count, index;
369: int s, error;
370:
371: index = cmapp->index;
372: count = cmapp->count;
373:
374: if (index >= BT463_NCMAP_ENTRIES || count > BT463_NCMAP_ENTRIES - index)
375: return (EINVAL);
376:
377: s = spltty();
378:
379: if ((error = copyin(cmapp->red, &data->cmap_r[index], count)) != 0) {
380: splx(s);
381: return (error);
382: }
383: if ((error = copyin(cmapp->green, &data->cmap_g[index], count)) != 0) {
384: splx(s);
385: return (error);
386: }
387: if ((error = copyin(cmapp->blue, &data->cmap_b[index], count)) != 0) {
388: splx(s);
389: return (error);
390: }
391:
392: data->changed |= DATA_CMAP_CHANGED;
393:
394: data->ramdac_sched_update(data->cookie, bt463_update);
395: splx(s);
396:
397: return (0);
398: }
399:
400: int
401: bt463_get_cmap(rc, cmapp)
402: struct ramdac_cookie *rc;
403: struct wsdisplay_cmap *cmapp;
404: {
405: struct bt463data *data = (struct bt463data *)rc;
406: u_int count, index;
407: int error;
408:
409: count = cmapp->count;
410: index = cmapp->index;
411:
412: if (index >= BT463_NCMAP_ENTRIES || count > BT463_NCMAP_ENTRIES - index)
413: return (EINVAL);
414:
415: error = copyout(&data->cmap_r[index], cmapp->red, count);
416: if (error)
417: return (error);
418: error = copyout(&data->cmap_g[index], cmapp->green, count);
419: if (error)
420: return (error);
421: error = copyout(&data->cmap_b[index], cmapp->blue, count);
422: return (error);
423: }
424:
425: int
426: bt463_check_curcmap(rc, cursorp)
427: struct ramdac_cookie *rc;
428: struct wsdisplay_cursor *cursorp;
429: {
430: u_int index, count;
431: u_int8_t spare[2];
432: int error;
433:
434: index = cursorp->cmap.index;
435: count = cursorp->cmap.count;
436:
437: if (index >= 2 || count > 2 - index)
438: return (EINVAL);
439:
440: if ((error = copyin(&cursorp->cmap.red, &spare, count)) != 0)
441: return (error);
442: if ((error = copyin(&cursorp->cmap.green, &spare, count)) != 0)
443: return (error);
444: if ((error = copyin(&cursorp->cmap.blue, &spare, count)) != 0)
445: return (error);
446:
447: return (0);
448: }
449:
450: void
451: bt463_set_curcmap(rc, cursorp)
452: struct ramdac_cookie *rc;
453: struct wsdisplay_cursor *cursorp;
454: {
455: struct bt463data *data = (struct bt463data *)rc;
456: int count, index;
457:
458: /* can't fail; parameters have already been checked. */
459: count = cursorp->cmap.count;
460: index = cursorp->cmap.index;
461: copyin(cursorp->cmap.red, &data->curcmap_r[index], count);
462: copyin(cursorp->cmap.green, &data->curcmap_g[index], count);
463: copyin(cursorp->cmap.blue, &data->curcmap_b[index], count);
464: data->changed |= DATA_CURCMAP_CHANGED;
465: data->ramdac_sched_update(data->cookie, bt463_update);
466: }
467:
468: int
469: bt463_get_curcmap(rc, cursorp)
470: struct ramdac_cookie *rc;
471: struct wsdisplay_cursor *cursorp;
472: {
473: struct bt463data *data = (struct bt463data *)rc;
474: int error;
475:
476: cursorp->cmap.index = 0; /* DOCMAP */
477: cursorp->cmap.count = 2;
478: if (cursorp->cmap.red != NULL) {
479: error = copyout(data->curcmap_r, cursorp->cmap.red, 2);
480: if (error)
481: return (error);
482: }
483: if (cursorp->cmap.green != NULL) {
484: error = copyout(data->curcmap_g, cursorp->cmap.green, 2);
485: if (error)
486: return (error);
487: }
488: if (cursorp->cmap.blue != NULL) {
489: error = copyout(data->curcmap_b, cursorp->cmap.blue, 2);
490: if (error)
491: return (error);
492: }
493: return (0);
494: }
495:
496:
497: /*****************************************************************************/
498:
499: /*
500: * Internal functions.
501: */
502:
503: #ifdef BT463_DEBUG
504: int bt463_store(void *v)
505: {
506: struct bt463data *data = (struct bt463data *)v;
507:
508: data->changed = DATA_ALL_CHANGED;
509: data->ramdac_sched_update(data->cookie, bt463_update);
510: printf("Scheduled bt463 store\n");
511:
512: return 0;
513: }
514:
515:
516: int bt463_readback(void *v)
517: {
518: struct bt463data *data = (struct bt463data *)v;
519:
520: data->ramdac_sched_update(data->cookie, bt463_copyback);
521: printf("Scheduled bt463 copyback\n");
522: return 0;
523: }
524:
525: int
526: bt463_debug(v)
527: void *v;
528: {
529: struct bt463data *data = (struct bt463data *)v;
530: int i;
531: u_int8_t val;
532:
533: printf("BT463 main regs:\n");
534: for (i = 0x200; i < 0x20F; i ++) {
535: val = BTRREG(data, i);
536: printf(" $%04x %02x\n", i, val);
537: }
538:
539: printf("BT463 revision register:\n");
540: val = BTRREG(data, 0x220);
541: printf(" $%04x %02x\n", 0x220, val);
542:
543: printf("BT463 window type table (from softc):\n");
544:
545: for (i = 0; i < BT463_NWTYPE_ENTRIES; i++) {
546: printf("%02x %06x\n", i, data->window_type[i]);
547: }
548:
549: return 0;
550: }
551:
552: void
553: bt463_copyback(p)
554: void *p;
555: {
556: struct bt463data *data = (struct bt463data *)p;
557: int i;
558:
559: for (i = 0; i < BT463_NWTYPE_ENTRIES; i++) {
560: bt463_wraddr(data, BT463_IREG_WINDOW_TYPE_TABLE + i);
561: data->window_type[i] = (BTRNREG(data) & 0xff); /* B0-7 */
562: data->window_type[i] |= (BTRNREG(data) & 0xff) << 8; /* B8-15 */
563: data->window_type[i] |= (BTRNREG(data) & 0xff) << 16; /* B16-23 */
564: }
565: }
566: #endif
567:
568: inline void
569: bt463_wraddr(data, ireg)
570: struct bt463data *data;
571: u_int16_t ireg;
572: {
573: data->ramdac_wr(data->cookie, BT463_REG_ADDR_LOW, ireg & 0xff);
574: data->ramdac_wr(data->cookie, BT463_REG_ADDR_HIGH, (ireg >> 8) & 0xff);
575: }
576:
577: void
578: bt463_update(p)
579: void *p;
580: {
581: struct bt463data *data = (struct bt463data *)p;
582: int i, v;
583:
584: if (console_data != NULL) {
585: /* The cookie passed in from sched_update is incorrect. Use the
586: * right one.
587: */
588: data = console_data;
589: }
590:
591: v = data->changed;
592:
593: /* The Bt463 won't accept window type data except during a blanking
594: * interval, so we do this early in the interrupt.
595: * Blanking the screen might also be a good idea, but it can cause
596: * unpleasant flashing and is hard to do from this side of the
597: * ramdac interface.
598: */
599: if (v & DATA_WTYPE_CHANGED) {
600: /* spit out the window type data */
601: for (i = 0; i < BT463_NWTYPE_ENTRIES; i++) {
602: bt463_wraddr(data, BT463_IREG_WINDOW_TYPE_TABLE + i);
603: BTWNREG(data, (data->window_type[i]) & 0xff); /* B0-7 */
604: BTWNREG(data, (data->window_type[i] >> 8) & 0xff); /* B8-15 */
605: BTWNREG(data, (data->window_type[i] >> 16) & 0xff); /* B16-23 */
606: }
607: }
608:
609: if (v & DATA_CURCMAP_CHANGED) {
610: bt463_wraddr(data, BT463_IREG_CURSOR_COLOR_0);
611: /* spit out the cursor data */
612: for (i = 0; i < 2; i++) {
613: BTWNREG(data, data->curcmap_r[i]);
614: BTWNREG(data, data->curcmap_g[i]);
615: BTWNREG(data, data->curcmap_b[i]);
616: }
617: }
618:
619: if (v & DATA_CMAP_CHANGED) {
620: bt463_wraddr(data, BT463_IREG_CPALETTE_RAM);
621: /* spit out the colormap data */
622: for (i = 0; i < BT463_NCMAP_ENTRIES; i++) {
623: data->ramdac_wr(data->cookie, BT463_REG_CMAP_DATA,
624: data->cmap_r[i]);
625: data->ramdac_wr(data->cookie, BT463_REG_CMAP_DATA,
626: data->cmap_g[i]);
627: data->ramdac_wr(data->cookie, BT463_REG_CMAP_DATA,
628: data->cmap_b[i]);
629: }
630: }
631:
632: data->changed = 0;
633: }
634:
635: int bt463_set_cursor (rc, cur)
636: struct ramdac_cookie *rc;
637: struct wsdisplay_cursor *cur;
638: {
639: struct bt463data *data = (struct bt463data *)rc;
640: return tga_builtin_set_cursor(data->cookie, cur);
641: }
642:
643: int bt463_get_cursor (rc, cur)
644: struct ramdac_cookie *rc;
645: struct wsdisplay_cursor *cur;
646: {
647: struct bt463data *data = (struct bt463data *)rc;
648: return tga_builtin_get_cursor(data->cookie, cur);
649: }
650:
651: int bt463_set_curpos (rc, cur)
652: struct ramdac_cookie *rc;
653: struct wsdisplay_curpos *cur;
654: {
655: struct bt463data *data = (struct bt463data *)rc;
656: return tga_builtin_set_curpos(data->cookie, cur);
657: }
658:
659: int bt463_get_curpos (rc, cur)
660: struct ramdac_cookie *rc;
661: struct wsdisplay_curpos *cur;
662: {
663: struct bt463data *data = (struct bt463data *)rc;
664: return tga_builtin_get_curpos(data->cookie, cur);
665: }
666:
667: int bt463_get_curmax (rc, cur)
668: struct ramdac_cookie *rc;
669: struct wsdisplay_curpos *cur;
670: {
671: struct bt463data *data = (struct bt463data *)rc;
672: return tga_builtin_get_curmax(data->cookie, cur);
673: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to bt463.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic