1/*	$NetBSD: leo.c,v 1.18 2011/06/10 09:29:07 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.18 2011/06/10 09:29:07 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
69static 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
80struct 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
93static int leo_match(device_t, cfdata_t, void *);
94static void leo_attach(device_t, device_t, void *);
95static 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);
98static int leo_init(struct leo_softc *, int);
99static int leo_scroll(struct leo_softc *, int);
100
101CFATTACH_DECL_NEW(leo, sizeof(struct leo_softc),
102    leo_match, leo_attach, NULL, NULL);
103
104dev_type_open(leoopen);
105dev_type_close(leoclose);
106dev_type_read(leomove);
107dev_type_ioctl(leoioctl);
108dev_type_mmap(leommap);
109
110const struct cdevsw leo_cdevsw = {
111	leoopen, leoclose, leomove, leomove, leoioctl,
112	nostop, notty, nopoll, leommap, nokqfilter,
113};
114
115static int
116leo_match(device_t parent, cfdata_t cf, void *aux)
117{
118	struct vme_attach_args *va = aux;
119	int i;
120	bus_space_tag_t iot;
121	bus_space_tag_t memt;
122	bus_space_handle_t ioh;
123	bus_space_handle_t memh;
124
125	/*
126	 * We are passed our configuration in the attachment arguments.
127	 * The configuration information may be partially unspecified.
128	 * For any unspecified configuration parameters, we fill in those
129	 * parameters with data for a "standard" configuration.
130	 * Once we have a fully specified configuration, we try to probe
131	 * a card with that configuration.
132	 * The Leonardo only has one configuration and it isn't likely
133	 * to change, but this routine doesn't assume that's the case.
134	 */
135	iot = va->va_iot;
136	memt = va->va_memt;
137	for (i = 0; i < NLEOSTD; i++) {
138		struct leo_addresses *leo_ap = &leostd[i];
139		int found = 0;
140		struct vme_attach_args vat = *va;
141
142		if (vat.va_irq != VMECF_IRQ_DEFAULT) {
143			printf("leo_match: config error: no irq support\n");
144			return 0;
145		}
146		if (vat.va_iobase == VMECF_IOPORT_DEFAULT)
147			vat.va_iobase = leo_ap->reg_addr;
148		if (vat.va_maddr == VMECF_MEM_DEFAULT)
149			vat.va_maddr = leo_ap->mem_addr;
150		if (vat.va_iosize == VMECF_IOSIZE_DEFAULT)
151			vat.va_iosize = leo_ap->reg_size;
152		if (vat.va_msize == VMECF_MEMSIZ_DEFAULT)
153			vat.va_msize = leo_ap->mem_size;
154		if (bus_space_map(iot, vat.va_iobase, vat.va_iosize, 0, &ioh)) {
155			printf("leo_match: cannot map io area\n");
156			return 0;
157		}
158		if (bus_space_map(memt, vat.va_maddr, vat.va_msize,
159			  	  BUS_SPACE_MAP_LINEAR|BUS_SPACE_MAP_CACHEABLE,
160			  	  &memh)) {
161			bus_space_unmap(iot, ioh, vat.va_iosize);
162			printf("leo_match: cannot map memory area\n");
163			return 0;
164		}
165		found = leo_probe(&iot, &memt, &ioh, &memh,
166				  vat.va_iosize, vat.va_msize);
167		bus_space_unmap(iot, ioh, vat.va_iosize);
168		bus_space_unmap(memt, memh, vat.va_msize);
169		if (found) {
170			*va = vat;
171			return 1;
172		}
173	}
174	return 0;
175}
176
177static int
178leo_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)
179{
180
181	/* Test that our highest register is within the io range. */
182	if (0xca > iosize) /* XXX */
183		return 0;
184	/* Test if we can peek each register. */
185	if (!bus_space_peek_1(*iot, *ioh, LEO_REG_MSBSCROLL))
186		return 0;
187	if (!bus_space_peek_1(*iot, *ioh, LEO_REG_LSBSCROLL))
188		return 0;
189	/*
190	 * Write a test pattern at the start and end of the memory region,
191	 * and test if the pattern can be read back.  If so, the region is
192	 * backed by memory (i.e. the card is present).
193	 * On the Leonardo, the first byte of each longword isn't backed by
194	 * physical memory, so we only compare the three low-order bytes
195	 * with the test pattern.
196	 */
197	bus_space_write_4(*memt, *memh, 0, 0xa5a5a5a5);
198	if ((bus_space_read_4(*memt, *memh, 0) & 0xffffff) != 0xa5a5a5)
199		return 0;
200	bus_space_write_4(*memt, *memh, msize - 4, 0xa5a5a5a5);
201	if ((bus_space_read_4(*memt, *memh, msize - 4) & 0xffffff)
202		!= 0xa5a5a5)
203		return 0;
204	return 1;
205}
206
207static void
208leo_attach(device_t parent, device_t self, void *aux)
209{
210	struct leo_softc *sc = device_private(self);
211	struct vme_attach_args *va = aux;
212	bus_space_handle_t ioh;
213	bus_space_handle_t memh;
214#ifndef SET_REGION
215	int i;
216#endif
217
218	sc->sc_dev = self;
219
220	printf("\n");
221	if (bus_space_map(va->va_iot, va->va_iobase, va->va_iosize, 0, &ioh))
222		panic("leo_attach: cannot map io area");
223	if (bus_space_map(va->va_memt, va->va_maddr, va->va_msize,
224			  BUS_SPACE_MAP_LINEAR|BUS_SPACE_MAP_CACHEABLE, &memh))
225		panic("leo_attach: cannot map memory area");
226#ifdef SET_REGION /* XXX seems to be unimplemented on atari? */
227	bus_space_set_region_4(va->va_memt, memh, 0, 0, va->va_msize >> 2);
228#else
229	for (i = 0; i < (va->va_msize >> 2); i++)
230		bus_space_write_4(va->va_memt, memh, i << 2, 0);
231#endif
232	sc->sc_iot = va->va_iot;
233	sc->sc_ioh = ioh;
234	sc->sc_memt = va->va_memt;
235	sc->sc_memh = memh;
236	sc->sc_flags = 0;
237	sc->sc_maddr = va->va_maddr;
238	sc->sc_msize = va->va_msize;
239	leo_init(sc, 512);
240	leo_scroll(sc, 0);
241}
242
243int
244leoopen(dev_t dev, int flags, int devtype, struct lwp *l)
245{
246	struct leo_softc *sc;
247	int r;
248
249	sc = device_lookup_private(&leo_cd, minor(dev));
250	if (!sc)
251		return ENXIO;
252	if (sc->sc_flags & LEO_SC_FLAGS_INUSE)
253		return EBUSY;
254	r = leo_init(sc, 512);
255	if (r != 0)
256		return r;
257	r = leo_scroll(sc, 0);
258	if (r != 0)
259		return r;
260	sc->sc_flags |= LEO_SC_FLAGS_INUSE;
261	return 0;
262}
263
264static int
265leo_init(struct leo_softc *sc, int ysize)
266{
267
268	if ((ysize != 256) && (ysize != 384) && (ysize != 512))
269		return EINVAL;
270	/* XXX */
271	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x00, 0x6);
272	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x08, 0x0);
273	if (ysize == 384)
274		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x10, 0x10);
275	else
276		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x10, 0x11);
277	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x18, 0x0);
278	if (ysize == 384)
279		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x20, 0x50);
280	else
281		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x20, 0x51);
282	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x28, 0x0);
283	if (ysize == 384)
284		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x30, 0x56);
285	else
286		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x30, 0x57);
287	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x38, 0x0);
288	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x40, 0x6);
289	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x48, 0x0);
290	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x50, 0x25);
291	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x58, 0x0);
292	if (ysize == 256) {
293		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x60, 0x1f);
294		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x68, 0x1);
295		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x70, 0x29);
296		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x78, 0x1);
297	} else if (ysize == 384) {
298		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x60, 0xa5);
299		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x68, 0x1);
300		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x70, 0xa7);
301		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x78, 0x1);
302	} else {
303		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x60, 0x1d);
304		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x68, 0x2);
305		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x70, 0x27);
306		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x78, 0x2);
307	}
308	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0xb8, 0x10);
309	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0xb0, 0x10);
310	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0x80, 0x4);
311	if (ysize == 384)
312		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0xc8, 0x21);
313	else
314		bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0xc8, 0x20);
315	bus_space_write_2(sc->sc_iot, sc->sc_ioh, 0xc0, 0x40);
316	return 0;
317}
318
319static int
320leo_scroll(struct leo_softc *sc, int scroll)
321{
322
323	if ((scroll < 0) || (scroll > 255))
324		return EINVAL;
325        bus_space_write_1(sc->sc_iot, sc->sc_ioh, LEO_REG_MSBSCROLL,
326			  (scroll >> 6) && 0xff);
327        bus_space_write_1(sc->sc_iot, sc->sc_ioh, LEO_REG_LSBSCROLL,
328			  (scroll << 2) && 0xff);
329	return 0;
330}
331
332int
333leoclose(dev_t dev, int flags, int devtype, struct lwp *l)
334{
335	struct leo_softc *sc;
336
337	sc = device_lookup_private(&leo_cd, minor(dev));
338	sc->sc_flags &= ~LEO_SC_FLAGS_INUSE;
339	return 0;
340}
341
342#define SMALLBSIZE      32
343
344int
345leomove(dev_t dev, struct uio *uio, int flags)
346{
347        struct leo_softc *sc;
348        int length, size, error;
349        u_int8_t smallbuf[SMALLBSIZE];
350	off_t offset;
351
352        sc = device_lookup_private(&leo_cd,minor(dev));
353        if (uio->uio_offset > sc->sc_msize)
354                return 0;
355        length = sc->sc_msize - uio->uio_offset;
356        if (length > uio->uio_resid)
357                length = uio->uio_resid;
358        while (length > 0) {
359                size = length;
360                if (size > SMALLBSIZE)
361                        size = SMALLBSIZE;
362                length -= size;
363		offset = uio->uio_offset;
364                if (uio->uio_rw == UIO_READ)
365                        bus_space_read_region_1(sc->sc_memt, sc->sc_memh,
366                                        offset, smallbuf, size);
367                if ((error = uiomove((void *)smallbuf, size, uio)))
368                        return (error);
369                if (uio->uio_rw == UIO_WRITE)
370                        bus_space_write_region_1(sc->sc_memt, sc->sc_memh,
371                                        offset, smallbuf, size);
372        }
373        return 0;
374}
375
376int
377leoioctl(dev_t dev, u_long cmd, void *data, int flags, struct lwp *l)
378{
379	struct leo_softc *sc;
380
381	sc = device_lookup_private(&leo_cd,minor(dev));
382        switch (cmd) {
383        case LIOCYRES:
384		return leo_init(sc, *(int *)data);
385		break;
386        case LIOCSCRL:
387		return leo_scroll(sc, *(int *)data);
388		break;
389	default:
390		return EINVAL;
391		break;
392	}
393}
394
395paddr_t
396leommap(dev_t dev, off_t offset, int prot)
397{
398	struct leo_softc *sc;
399
400	sc = device_lookup_private(&leo_cd, minor(dev));
401	if (offset >= 0 && offset < sc->sc_msize)
402		return m68k_btop(sc->sc_maddr + offset);
403	return -1;
404}
405