1 /* $NetBSD: leo.c,v 1.24 2023/01/06 10:28:28 tsutsui Exp $ */
2
3 /*-
4 * Copyright (c) 1997 maximum entropy <entropy@zippy.bernstein.com>
5 * Copyright (c) 1997 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 /*
31 * Driver for the Circad Leonardo 1.2 from Lexicor, a 24-bit true color
32 * VME graphics card based on the Texas Instruments TMS34061.
33 *
34 * Written by maximum entropy <entropy@zippy.bernstein.com>, December 5, 1997.
35 *
36 * This driver was written from scratch, but I referred to several other
37 * drivers in the NetBSD distribution as examples. The file I referred to
38 * the most was /sys/arch/atari/vme/if_le_vme.c. Due credits:
39 * Copyright (c) 1997 Leo Weppelman. All rights reserved.
40 * Copyright (c) 1995 Charles M. Hannum. All rights reserved.
41 * Copyright (c) 1992, 1993
42 * The Regents of the University of California. All rights reserved.
43 * This code is derived from software contributed to Berkeley by
44 * Ralph Campbell and Rick Macklem.
45 * This product includes software developed by the University of
46 * California, Berkeley and its contributors.
47 */
48
49 #include <sys/cdefs.h>
50 __KERNEL_RCSID(0, "$NetBSD: leo.c,v 1.24 2023/01/06 10:28:28 tsutsui Exp $");
51
52 #include <sys/param.h>
53 #include <sys/systm.h>
54 #include <sys/proc.h>
55 #include <sys/errno.h>
56 #include <sys/device.h>
57 #include <sys/conf.h>
58 #include <sys/ioctl.h>
59 #include <machine/cpu.h>
60 #include <sys/bus.h>
61 #include <machine/iomap.h>
62 #include <machine/scu.h>
63 #include <atari/vme/vmevar.h>
64 #include <atari/vme/leovar.h>
65 #include <atari/vme/leoioctl.h>
66
67 #include "ioconf.h"
68
69 static struct leo_addresses {
70 u_long reg_addr;
71 u_int reg_size;
72 u_long mem_addr;
73 u_int mem_size;
74 } leostd[] = {
75 { 0xfed90000, 0x100, 0xfec00000, 0x100000 }
76 };
77
78 #define NLEOSTD (sizeof(leostd) / sizeof(leostd[0]))
79
80 struct leo_softc {
81 device_t sc_dev; /* XXX what goes here? */
82 bus_space_tag_t sc_iot;
83 bus_space_tag_t sc_memt;
84 bus_space_handle_t sc_ioh;
85 bus_space_handle_t sc_memh;
86 int sc_flags;
87 int sc_maddr;
88 u_int sc_msize;
89 };
90
91 #define LEO_SC_FLAGS_INUSE 1
92
93 static int leo_match(device_t, cfdata_t, void *);
94 static void leo_attach(device_t, device_t, void *);
95 static int leo_probe(bus_space_tag_t *, bus_space_tag_t *,
96 bus_space_handle_t *, bus_space_handle_t *,
97 u_int, u_int);
98 static int leo_init(struct leo_softc *, int);
99 static int leo_scroll(struct leo_softc *, int);
100
101 CFATTACH_DECL_NEW(leo, sizeof(struct leo_softc),
102 leo_match, leo_attach, NULL, NULL);
103
104 static dev_type_open(leoopen);
105 static dev_type_close(leoclose);
106 static dev_type_read(leomove);
107 static dev_type_ioctl(leoioctl);
108 static dev_type_mmap(leommap);
109
110 const struct cdevsw leo_cdevsw = {
111 .d_open = leoopen,
112 .d_close = leoclose,
113 .d_read = leomove,
114 .d_write = leomove,
115 .d_ioctl = leoioctl,
116 .d_stop = nostop,
117 .d_tty = notty,
118 .d_poll = nopoll,
119 .d_mmap = leommap,
120 .d_kqfilter = nokqfilter,
121 .d_discard = nodiscard,
122 .d_flag = 0
123 };
124
125 static int
leo_match(device_t parent,cfdata_t cf,void * aux)126 leo_match(device_t parent, cfdata_t cf, void *aux)
127 {
128 struct vme_attach_args *va = aux;
129 int i;
130 bus_space_tag_t iot;
131 bus_space_tag_t memt;
132 bus_space_handle_t ioh;
133 bus_space_handle_t memh;
134
135 /*
136 * We are passed our configuration in the attachment arguments.
137 * The configuration information may be partially unspecified.
138 * For any unspecified configuration parameters, we fill in those
139 * parameters with data for a "standard" configuration.
140 * Once we have a fully specified configuration, we try to probe
141 * a card with that configuration.
142 * The Leonardo only has one configuration and it isn't likely
143 * to change, but this routine doesn't assume that's the case.
144 */
145 iot = va->va_iot;
146 memt = va->va_memt;
147 for (i = 0; i < NLEOSTD; i++) {
148 struct leo_addresses *leo_ap = &leostd[i];
149 int found = 0;
150 struct vme_attach_args vat = *va;
151
152 if (vat.va_irq != VMECF_IRQ_DEFAULT) {
153 printf("leo_match: config error: no irq support\n");
154 return 0;
155 }
156 if (vat.va_iobase == VMECF_IOPORT_DEFAULT)
157 vat.va_iobase = leo_ap->reg_addr;
158 if (vat.va_maddr == VMECF_MEM_DEFAULT)
159 vat.va_maddr = leo_ap->mem_addr;
160 if (vat.va_iosize == VMECF_IOSIZE_DEFAULT)
161 vat.va_iosize = leo_ap->reg_size;
162 if (vat.va_msize == VMECF_MEMSIZ_DEFAULT)
163 vat.va_msize = leo_ap->mem_size;
164 if (bus_space_map(iot, vat.va_iobase, vat.va_iosize, 0, &ioh)) {
165 printf("leo_match: cannot map io area\n");
166 return 0;
167 }
168 if (bus_space_map(memt, vat.va_maddr, vat.va_msize,
169 BUS_SPACE_MAP_LINEAR|BUS_SPACE_MAP_CACHEABLE,
170 &memh)) {
171 bus_space_unmap(iot, ioh, vat.va_iosize);
172 printf("leo_match: cannot map memory area\n");
173 return 0;
174 }
175 found = leo_probe(&iot, &memt, &ioh, &memh,
176 vat.va_iosize, vat.va_msize);
177 bus_space_unmap(iot, ioh, vat.va_iosize);
178 bus_space_unmap(memt, memh, vat.va_msize);
179 if (found) {
180 *va = vat;
181 return 1;
182 }
183 }
184 return 0;
185 }
186
187 static int
leo_probe(bus_space_tag_t * iot,bus_space_tag_t * memt,bus_space_handle_t * ioh,bus_space_handle_t * memh,u_int iosize,u_int msize)188 leo_probe(bus_space_tag_t *iot, bus_space_tag_t *memt, bus_space_handle_t *ioh, bus_space_handle_t *memh, u_int iosize, u_int msize)
189 {
190
191 /* Test that our highest register is within the io range. */
192 if (0xca > iosize) /* XXX */
193 return 0;
194 /* Test if we can peek each register. */
195 if (!bus_space_peek_1(*iot, *ioh, LEO_REG_MSBSCROLL))
196 return 0;
197 if (!bus_space_peek_1(*iot, *ioh, LEO_REG_LSBSCROLL))
198 return 0;
199 /*
200 * Write a test pattern at the start and end of the memory region,
201 * and test if the pattern can be read back. If so, the region is
202 * backed by memory (i.e. the card is present).
203 * On the Leonardo, the first byte of each longword isn't backed by
204 * physical memory, so we only compare the three low-order bytes
205 * with the test pattern.
206 */
207 bus_space_write_4(*memt, *memh, 0, 0xa5a5a5a5);
208 if ((bus_space_read_4(*memt, *memh, 0) & 0xffffff) != 0xa5a5a5)
209 return 0;
210 bus_space_write_4(*memt, *memh, msize - 4, 0xa5a5a5a5);
211 if ((bus_space_read_4(*memt, *memh, msize - 4) & 0xffffff)
212 != 0xa5a5a5)
213 return 0;
214 return 1;
215 }
216
217 static void
leo_attach(device_t parent,device_t self,void * aux)218 leo_attach(device_t parent, device_t self, void *aux)
219 {
220 struct leo_softc *sc = device_private(self);
221 struct vme_attach_args *va = aux;
222 bus_space_handle_t ioh;
223 bus_space_handle_t memh;
224 #ifndef SET_REGION
225 int i;
226 #endif
227
228 sc->sc_dev = self;
229
230 printf("\n");
231 if (bus_space_map(va->va_iot, va->va_iobase, va->va_iosize, 0, &ioh))
232 panic("leo_attach: cannot map io area");
233 if (bus_space_map(va->va_memt, va->va_maddr, va->va_msize,
234 BUS_SPACE_MAP_LINEAR|BUS_SPACE_MAP_CACHEABLE, &memh))
235 panic("leo_attach: cannot map memory area");
236 #ifdef SET_REGION /* XXX seems to be unimplemented on atari? */
237 bus_space_set_region_4(va->va_memt, memh, 0, 0, va->va_msize >> 2);
238 #else
239 for (i = 0; i < (va->va_msize >> 2); i++)
240 bus_space_write_4(va->va_memt, memh, i << 2, 0);
241 #endif
242 sc->sc_iot = va->va_iot;
243 sc->sc_ioh = ioh;
244 sc->sc_memt = va->va_memt;
245 sc->sc_memh = memh;
246 sc->sc_flags = 0;
247 sc->sc_maddr = va->va_maddr;
248 sc->sc_msize = va->va_msize;
249 leo_init(sc, 512);
250 leo_scroll(sc, 0);
251 }
252
253 int
leoopen(dev_t dev,int flags,int devtype,struct lwp * l)254 leoopen(dev_t dev, int flags, int devtype, struct lwp *l)
255 {
256 struct leo_softc *sc;
257 int r;
258
259 sc = device_lookup_private(&leo_cd, minor(dev));
260 if (!sc)
261 return ENXIO;
262 if (sc->sc_flags & LEO_SC_FLAGS_INUSE)
263 return EBUSY;
264 r = leo_init(sc, 512);
265 if (r != 0)
266 return r;
267 r = leo_scroll(sc, 0);
268 if (r != 0)
269 return r;
270 sc->sc_flags |= LEO_SC_FLAGS_INUSE;
271 return 0;
272 }
273
274 static int
leo_init(struct leo_softc * sc,int ysize)275 leo_init(struct leo_softc *sc, int ysize)
276 {
277
278 if ((ysize != 256) && (ysize != 384) && (ysize != 512))
279 return EINVAL;
280 /* XXX */
281 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x00, 0x6);
282 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x08, 0x0);
283 if (ysize == 384)
284 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x10, 0x10);
285 else
286 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x10, 0x11);
287 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x18, 0x0);
288 if (ysize == 384)
289 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x20, 0x50);
290 else
291 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x20, 0x51);
292 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x28, 0x0);
293 if (ysize == 384)
294 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x30, 0x56);
295 else
296 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x30, 0x57);
297 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x38, 0x0);
298 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x40, 0x6);
299 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x48, 0x0);
300 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x50, 0x25);
301 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x58, 0x0);
302 if (ysize == 256) {
303 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x60, 0x1f);
304 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x68, 0x1);
305 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x70, 0x29);
306 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x78, 0x1);
307 } else if (ysize == 384) {
308 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x60, 0xa5);
309 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x68, 0x1);
310 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x70, 0xa7);
311 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x78, 0x1);
312 } else {
313 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x60, 0x1d);
314 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x68, 0x2);
315 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x70, 0x27);
316 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x78, 0x2);
317 }
318 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0xb8, 0x10);
319 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0xb0, 0x10);
320 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x80, 0x4);
321 if (ysize == 384)
322 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0xc8, 0x21);
323 else
324 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0xc8, 0x20);
325 bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0xc0, 0x40);
326 return 0;
327 }
328
329 static int
leo_scroll(struct leo_softc * sc,int scroll)330 leo_scroll(struct leo_softc *sc, int scroll)
331 {
332
333 if ((scroll < 0) || (scroll > 255))
334 return EINVAL;
335 bus_space_write_1(sc->sc_iot, sc->sc_ioh, LEO_REG_MSBSCROLL,
336 (scroll >> 6) & 0xff);
337 bus_space_write_1(sc->sc_iot, sc->sc_ioh, LEO_REG_LSBSCROLL,
338 (scroll << 2) & 0xff);
339 return 0;
340 }
341
342 int
leoclose(dev_t dev,int flags,int devtype,struct lwp * l)343 leoclose(dev_t dev, int flags, int devtype, struct lwp *l)
344 {
345 struct leo_softc *sc;
346
347 sc = device_lookup_private(&leo_cd, minor(dev));
348 sc->sc_flags &= ~LEO_SC_FLAGS_INUSE;
349 return 0;
350 }
351
352 #define SMALLBSIZE 32
353
354 int
leomove(dev_t dev,struct uio * uio,int flags)355 leomove(dev_t dev, struct uio *uio, int flags)
356 {
357 struct leo_softc *sc;
358 int length, size, error;
359 u_int8_t smallbuf[SMALLBSIZE];
360 off_t offset;
361
362 sc = device_lookup_private(&leo_cd,minor(dev));
363 if (uio->uio_offset > sc->sc_msize)
364 return 0;
365 length = sc->sc_msize - uio->uio_offset;
366 if (length > uio->uio_resid)
367 length = uio->uio_resid;
368 while (length > 0) {
369 size = length;
370 if (size > SMALLBSIZE)
371 size = SMALLBSIZE;
372 length -= size;
373 offset = uio->uio_offset;
374 if (uio->uio_rw == UIO_READ)
375 bus_space_read_region_1(sc->sc_memt, sc->sc_memh,
376 offset, smallbuf, size);
377 if ((error = uiomove((void *)smallbuf, size, uio)))
378 return (error);
379 if (uio->uio_rw == UIO_WRITE)
380 bus_space_write_region_1(sc->sc_memt, sc->sc_memh,
381 offset, smallbuf, size);
382 }
383 return 0;
384 }
385
386 int
leoioctl(dev_t dev,u_long cmd,void * data,int flags,struct lwp * l)387 leoioctl(dev_t dev, u_long cmd, void *data, int flags, struct lwp *l)
388 {
389 struct leo_softc *sc;
390
391 sc = device_lookup_private(&leo_cd,minor(dev));
392 switch (cmd) {
393 case LIOCYRES:
394 return leo_init(sc, *(int *)data);
395 break;
396 case LIOCSCRL:
397 return leo_scroll(sc, *(int *)data);
398 break;
399 default:
400 return EINVAL;
401 break;
402 }
403 }
404
405 paddr_t
leommap(dev_t dev,off_t offset,int prot)406 leommap(dev_t dev, off_t offset, int prot)
407 {
408 struct leo_softc *sc;
409
410 sc = device_lookup_private(&leo_cd, minor(dev));
411 if (offset >= 0 && offset < sc->sc_msize)
412 return m68k_btop(sc->sc_maddr + offset);
413 return -1;
414 }
415