1 /* $OpenBSD: agten.c,v 1.14 2024/05/13 01:15:51 jsg Exp $ */
2 /*
3 * Copyright (c) 2002, 2003, Miodrag Vallat.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
19 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
23 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
24 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 * POSSIBILITY OF SUCH DAMAGE.
26 *
27 */
28
29 /*
30 * Fujitsu AG-10 framebuffer driver.
31 *
32 * The AG-10 is mostly made of:
33 * - a 3DLabs 300SX Glint chip, with two 6MB independent framebuffer spaces
34 * - a Number Nine Imagine 128 chip with its own 4MB framebuffer space
35 * - a Weitek P9100 with its own 2MB of framebuffer memory
36 * - an IBM PaletteDAC 561 ramdac
37 * - an Analog Devices ADSP-21062
38 *
39 * All of these chips (memory, registers, etc) are mapped in the SBus
40 * memory space associated to the board. What is unexpected, however, is
41 * that there are also PCI registers mappings for the first three chips!
42 *
43 * The three graphics chips act as overlays of each other, for the final
44 * video output.
45 *
46 * The PROM initialization will use the I128 framebuffer memory for output,
47 * which is ``above'' the P9100. The P9100 seems to only be there to provide
48 * a simple RAMDAC interface, but its frame buffer memory is accessible and
49 * will appear as an ``underlay'' plane.
50 */
51
52 /*
53 * TODO
54 * - initialize the I128 in 32bit mode
55 * - use the i128 acceleration features
56 */
57
58 #include <sys/param.h>
59 #include <sys/systm.h>
60 #include <sys/buf.h>
61 #include <sys/device.h>
62 #include <sys/ioctl.h>
63 #include <sys/malloc.h>
64 #include <sys/mman.h>
65 #include <sys/tty.h>
66 #include <sys/conf.h>
67
68 #include <uvm/uvm_extern.h>
69
70 #include <machine/autoconf.h>
71 #include <machine/pmap.h>
72 #include <machine/cpu.h>
73 #include <machine/conf.h>
74
75 #include <dev/wscons/wsconsio.h>
76 #include <dev/wscons/wsdisplayvar.h>
77 #include <dev/rasops/rasops.h>
78 #include <machine/fbvar.h>
79
80 #include <dev/ic/p9000.h>
81 #include <dev/ic/ibm561reg.h>
82
83 #include <dev/sbus/sbusvar.h>
84
85 struct agten_cmap {
86 u_int8_t cm_red[256];
87 u_int8_t cm_green[256];
88 u_int8_t cm_blue[256];
89 };
90
91 /* per-display variables */
92 struct agten_softc {
93 struct sunfb sc_sunfb; /* common base part */
94
95 bus_space_tag_t sc_bustag;
96 bus_addr_t sc_paddr;
97 off_t sc_physoffset; /* offset for frame buffer */
98
99 volatile u_int8_t *sc_p9100;
100 struct agten_cmap sc_cmap; /* shadow color map */
101
102 volatile u_int32_t *sc_i128_fb;
103
104 int sc_nscreens;
105 };
106
107 int agten_ioctl(void *, u_long, caddr_t, int, struct proc *);
108 paddr_t agten_mmap(void *, off_t, int);
109 void agten_setcolor(void *, u_int, u_int8_t, u_int8_t, u_int8_t);
110
111 static __inline__ void ibm561_write(struct agten_softc *, u_int32_t, u_int32_t);
112 int agten_getcmap(struct agten_cmap *, struct wsdisplay_cmap *);
113 int agten_putcmap(struct agten_cmap *, struct wsdisplay_cmap *);
114 void agten_loadcmap(struct agten_softc *, u_int, u_int);
115
116 struct wsdisplay_accessops agten_accessops = {
117 .ioctl = agten_ioctl,
118 .mmap = agten_mmap
119 };
120
121 int agtenmatch(struct device *, void *, void *);
122 void agtenattach(struct device *, struct device *, void *);
123
124 const struct cfattach agten_ca = {
125 sizeof(struct agten_softc), agtenmatch, agtenattach
126 };
127
128 struct cfdriver agten_cd = {
129 NULL, "agten", DV_DULL
130 };
131
132 int
agtenmatch(struct device * parent,void * vcf,void * aux)133 agtenmatch(struct device *parent, void *vcf, void *aux)
134 {
135 struct sbus_attach_args *sa = aux;
136
137 if (strcmp(sa->sa_name, "PFU,aga") != 0)
138 return (0);
139
140 return (1);
141 }
142
143 void
agtenattach(struct device * parent,struct device * self,void * args)144 agtenattach(struct device *parent, struct device *self, void *args)
145 {
146 struct agten_softc *sc = (struct agten_softc *)self;
147 struct sbus_attach_args *sa = args;
148 bus_space_tag_t bt;
149 bus_space_handle_t bh;
150 int node, isconsole;
151 char *nam;
152
153 bt = sa->sa_bustag;
154 node = sa->sa_node;
155 nam = getpropstring(node, "model");
156 printf(": model %s", nam);
157
158 isconsole = node == fbnode;
159
160 /*
161 * Map the various beasts of this card we are interested in.
162 */
163
164 sc->sc_bustag = bt;
165 sc->sc_paddr = sbus_bus_addr(bt, sa->sa_slot, sa->sa_offset);
166
167 sc->sc_physoffset =
168 (off_t)getpropint(node, "i128_fb_physaddr", 0x8000000);
169
170 if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + sc->sc_physoffset,
171 getpropint(node, "i128_fb_size", 0x400000), BUS_SPACE_MAP_LINEAR,
172 0, &bh) != 0) {
173 printf("\n%s: couldn't map video memory\n", self->dv_xname);
174 return;
175 }
176 sc->sc_i128_fb = bus_space_vaddr(bt, bh);
177 if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset +
178 getpropint(node, "p9100_reg_physaddr", 0x10a0000), 0x4000,
179 BUS_SPACE_MAP_LINEAR, 0, &bh) != 0) {
180 printf("\n%s: couldn't map control registers\n", self->dv_xname);
181 return;
182 }
183 sc->sc_p9100 = bus_space_vaddr(bt, bh);
184
185 /*
186 * For some reason the agten does not use the canonical name for
187 * properties, but uses an ffb_ prefix; and the linebytes property is
188 * missing.
189 * The following is a specific version of
190 * fb_setsize(&sc->sc_sunfb, 8, 1152, 900, node, BUS_SBUS);
191 * using the correct property names.
192 */
193 #ifdef notyet
194 sc->sc_sunfb.sf_depth = 32;
195 #else
196 sc->sc_sunfb.sf_depth = getpropint(node, "ffb_depth", 8);
197 #endif
198 sc->sc_sunfb.sf_width = getpropint(node, "ffb_width", 1152);
199 sc->sc_sunfb.sf_height = getpropint(node, "ffb_height", 900);
200 sc->sc_sunfb.sf_linebytes =
201 roundup(sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_depth) *
202 sc->sc_sunfb.sf_depth / 8;
203 sc->sc_sunfb.sf_fbsize =
204 sc->sc_sunfb.sf_height * sc->sc_sunfb.sf_linebytes;
205
206 printf(", %dx%d, depth %d\n",
207 sc->sc_sunfb.sf_width, sc->sc_sunfb.sf_height,
208 sc->sc_sunfb.sf_depth);
209
210 sc->sc_sunfb.sf_ro.ri_bits = (void *)sc->sc_i128_fb;
211
212 sc->sc_sunfb.sf_ro.ri_hw = sc;
213 fbwscons_init(&sc->sc_sunfb, 0, isconsole);
214 fbwscons_setcolormap(&sc->sc_sunfb, agten_setcolor);
215
216 if (isconsole)
217 fbwscons_console_init(&sc->sc_sunfb, -1);
218
219 fbwscons_attach(&sc->sc_sunfb, &agten_accessops, isconsole);
220 }
221
222 int
agten_ioctl(void * dev,u_long cmd,caddr_t data,int flags,struct proc * p)223 agten_ioctl(void *dev, u_long cmd, caddr_t data, int flags, struct proc *p)
224 {
225 struct agten_softc *sc = dev;
226 struct wsdisplay_cmap *cm;
227 struct wsdisplay_fbinfo *wdf;
228 int error;
229
230 switch (cmd) {
231 case WSDISPLAYIO_GTYPE:
232 *(u_int *)data = WSDISPLAY_TYPE_AGTEN;
233 break;
234 case WSDISPLAYIO_GINFO:
235 wdf = (struct wsdisplay_fbinfo *)data;
236 wdf->height = sc->sc_sunfb.sf_height;
237 wdf->width = sc->sc_sunfb.sf_width;
238 wdf->depth = sc->sc_sunfb.sf_depth;
239 wdf->stride = sc->sc_sunfb.sf_linebytes;
240 wdf->offset = 0;
241 wdf->cmsize = (sc->sc_sunfb.sf_depth == 8) ? 256 : 0;
242 break;
243 case WSDISPLAYIO_LINEBYTES:
244 *(u_int *)data = sc->sc_sunfb.sf_linebytes;
245 break;
246
247 case WSDISPLAYIO_GETCMAP:
248 if (sc->sc_sunfb.sf_depth == 8) {
249 cm = (struct wsdisplay_cmap *)data;
250 error = agten_getcmap(&sc->sc_cmap, cm);
251 if (error)
252 return (error);
253 }
254 break;
255 case WSDISPLAYIO_PUTCMAP:
256 if (sc->sc_sunfb.sf_depth == 8) {
257 cm = (struct wsdisplay_cmap *)data;
258 error = agten_putcmap(&sc->sc_cmap, cm);
259 if (error)
260 return (error);
261 agten_loadcmap(sc, 0, 256);
262 }
263 break;
264
265 case WSDISPLAYIO_SVIDEO:
266 case WSDISPLAYIO_GVIDEO:
267 break;
268
269 case WSDISPLAYIO_GCURPOS:
270 case WSDISPLAYIO_SCURPOS:
271 case WSDISPLAYIO_GCURMAX:
272 case WSDISPLAYIO_GCURSOR:
273 case WSDISPLAYIO_SCURSOR:
274 default:
275 return (-1); /* not supported yet */
276 }
277
278 return (0);
279 }
280
281 /*
282 * Return the address that would map the given device at the given
283 * offset, allowing for the given protection, or return -1 for error.
284 */
285 paddr_t
agten_mmap(void * v,off_t offset,int prot)286 agten_mmap(void *v, off_t offset, int prot)
287 {
288 struct agten_softc *sc = v;
289
290 if (offset & PGOFSET)
291 return (-1);
292
293 /* Allow mapping as a dumb framebuffer from offset 0 */
294 if (offset >= 0 && offset < sc->sc_sunfb.sf_fbsize) {
295 return (bus_space_mmap(sc->sc_bustag, sc->sc_paddr,
296 sc->sc_physoffset + offset, prot, BUS_SPACE_MAP_LINEAR));
297 }
298
299 return (-1); /* not a user-map offset */
300 }
301
302 void
agten_setcolor(void * v,u_int index,u_int8_t r,u_int8_t g,u_int8_t b)303 agten_setcolor(void *v, u_int index, u_int8_t r, u_int8_t g, u_int8_t b)
304 {
305 struct agten_softc *sc = v;
306
307 sc->sc_cmap.cm_red[index] = r;
308 sc->sc_cmap.cm_green[index] = g;
309 sc->sc_cmap.cm_blue[index] = b;
310
311 agten_loadcmap(sc, index, 1);
312 }
313
314 int
agten_getcmap(struct agten_cmap * cm,struct wsdisplay_cmap * rcm)315 agten_getcmap(struct agten_cmap *cm, struct wsdisplay_cmap *rcm)
316 {
317 u_int index = rcm->index, count = rcm->count;
318 int error;
319
320 if (index >= 256 || count > 256 - index)
321 return (EINVAL);
322
323 if ((error = copyout(&cm->cm_red[index], rcm->red, count)) != 0)
324 return (error);
325 if ((error = copyout(&cm->cm_green[index], rcm->green, count)) != 0)
326 return (error);
327 if ((error = copyout(&cm->cm_blue[index], rcm->blue, count)) != 0)
328 return (error);
329
330 return (0);
331 }
332
333 int
agten_putcmap(struct agten_cmap * cm,struct wsdisplay_cmap * rcm)334 agten_putcmap(struct agten_cmap *cm, struct wsdisplay_cmap *rcm)
335 {
336 u_int index = rcm->index, count = rcm->count;
337 int error;
338
339 if (index >= 256 || count > 256 - index)
340 return (EINVAL);
341
342 if ((error = copyin(rcm->red, &cm->cm_red[index], count)) != 0)
343 return (error);
344 if ((error = copyin(rcm->green, &cm->cm_green[index], count)) != 0)
345 return (error);
346 if ((error = copyin(rcm->blue, &cm->cm_blue[index], count)) != 0)
347 return (error);
348
349 return (0);
350 }
351
352 static __inline__ void
ibm561_write(struct agten_softc * sc,u_int32_t reg,u_int32_t value)353 ibm561_write(struct agten_softc *sc, u_int32_t reg, u_int32_t value)
354 {
355 /*
356 * For some design reason the IBM561 PaletteDac needs to be fed
357 * values shifted left by 16 bits. What happened to simplicity?
358 */
359 *(volatile u_int32_t *)(sc->sc_p9100 + P9100_RAMDAC_REGISTER(reg)) =
360 (value) << 16;
361 }
362
363 void
agten_loadcmap(struct agten_softc * sc,u_int start,u_int ncolors)364 agten_loadcmap(struct agten_softc *sc, u_int start, u_int ncolors)
365 {
366 int i;
367 u_int8_t *red, *green, *blue;
368
369 ibm561_write(sc, IBM561_ADDR_LOW,
370 (IBM561_CMAP_TABLE + start) & 0xff);
371 ibm561_write(sc, IBM561_ADDR_HIGH,
372 ((IBM561_CMAP_TABLE + start) >> 8) & 0xff);
373
374 red = sc->sc_cmap.cm_red;
375 green = sc->sc_cmap.cm_green;
376 blue = sc->sc_cmap.cm_blue;
377 for (i = start; i < start + ncolors; i++) {
378 ibm561_write(sc, IBM561_CMD_CMAP, *red++);
379 ibm561_write(sc, IBM561_CMD_CMAP, *green++);
380 ibm561_write(sc, IBM561_CMD_CMAP, *blue++);
381 }
382 }
383