leo.c revision 1.24
1 /* $NetBSD: leo.c,v 1.24 2023/01/06 10:28:28 tsutsui Exp $ */ 2 3 /*- 4 * Copyright (c) 1997 maximum entropy <entropy (at) 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 (at) 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 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 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 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 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 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 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 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 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 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 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
Indexes created Tue Sep 30 20:09:53 GMT 2025