sys/arch/ews4800mips/sbd/fb_sbdio.c

   1 /*      $NetBSD: fb_sbdio.c,v 1.7 2008/04/28 20:23:18 martin Exp $      */
   2
   3 /*-
   4  * Copyright (c) 2004, 2005 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by UCHIYAMA Yasushi.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #define WIRED_FB_TLB
  33
  34 #include <sys/cdefs.h>
  35 __KERNEL_RCSID(0, "$NetBSD: fb_sbdio.c,v 1.7 2008/04/28 20:23:18 martin Exp $");
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/malloc.h>
  40 #include <dev/cons.h>
  41
  42 #include <uvm/uvm_extern.h>     /* pmap function to remap FB */
  43
  44 #include <dev/wscons/wsconsio.h>
  45 #include <dev/wscons/wsdisplayvar.h>
  46 #include <dev/wsfont/wsfont.h>
  47 #include <dev/rasops/rasops.h>
  48
  49 #include <mips/pte.h>
  50
  51 #include <machine/locore.h>
  52 #include <machine/sbdiovar.h>
  53
  54 #include <machine/gareg.h>
  55 #include <machine/gavar.h>
  56
  57 #include <machine/vmparam.h>
  58 #include <machine/wired_map.h>
  59
  60
  61 struct fb_softc {
  62         device_t sc_dev;
  63         struct rasops_info *sc_ri;
  64         struct ga *sc_ga;
  65         int sc_nscreens;
  66 };
  67
  68 int fb_sbdio_match(device_t, cfdata_t, void *);
  69 void fb_sbdio_attach(device_t, device_t, void *);
  70
  71 CFATTACH_DECL_NEW(fb_sbdio, sizeof(struct fb_softc),
  72     fb_sbdio_match, fb_sbdio_attach, NULL, NULL);
  73
  74 int _fb_ioctl(void *, void *, u_long, void *, int, struct lwp *);
  75 paddr_t _fb_mmap(void *, void *, off_t, int);
  76 int _fb_alloc_screen(void *, const struct wsscreen_descr *, void **,
  77     int *, int *, long *);
  78 void _fb_free_screen(void *, void *);
  79 int _fb_show_screen(void *, void *, int, void (*)(void *, int, int), void *);
  80 void _fb_pollc(void *, int);
  81 void fb_common_init(struct rasops_info *, struct ga *);
  82 int fb_sbdio_cnattach(uint32_t, uint32_t, int);
  83 void fb_pmap_enter(paddr_t, paddr_t, vaddr_t *, vaddr_t *);
  84
  85 struct wsscreen_descr _fb_std_screen = {
  86         "std", 0, 0,
  87         0, /* textops */
  88         0, 0,
  89         0
  90 };
  91
  92 const struct wsscreen_descr *_fb_screen_table[] = {
  93         &_fb_std_screen,
  94 };
  95
  96 struct wsscreen_list _fb_screen_list = {
  97         .nscreens       =
  98             sizeof(_fb_screen_table) / sizeof(_fb_screen_table[0]),
  99         .screens        = _fb_screen_table
 100 };
 101
 102 struct wsdisplay_accessops _fb_accessops = {
 103         .ioctl          = _fb_ioctl,
 104         .mmap           = _fb_mmap,
 105         .alloc_screen   = _fb_alloc_screen,
 106         .free_screen    = _fb_free_screen,
 107         .show_screen    = _fb_show_screen,
 108         .load_font      = 0,
 109         .pollc          = _fb_pollc
 110 };
 111
 112 /* console stuff */
 113 static struct rasops_info fb_console_ri;
 114 static struct ga fb_console_ga;
 115 static paddr_t fb_consaddr;
 116
 117
 118 int
 119 fb_sbdio_match(device_t parent, cfdata_t cf, void *aux)
 120 {
 121         struct sbdio_attach_args *sa = aux;
 122
 123         return strcmp(sa->sa_name, "fb") ? 0 : 1;
 124 }
 125
 126 void
 127 fb_sbdio_attach(device_t parent, device_t self, void *aux)
 128 {
 129         struct fb_softc *sc = device_private(self);
 130         struct sbdio_attach_args *sa = aux;
 131         struct wsemuldisplaydev_attach_args wa;
 132         struct rasops_info *ri;
 133         struct ga *ga;
 134         vaddr_t memva, regva;
 135         int console;
 136
 137         sc->sc_dev = self;
 138         aprint_normal("\n");
 139
 140         console = (sa->sa_addr1 == fb_consaddr);
 141         if (console) {
 142                 /* already initialized in fb_cnattach() */
 143                 sc->sc_ri = ri = &fb_console_ri;
 144                 sc->sc_ga = &fb_console_ga;
 145                 sc->sc_nscreens = 1;
 146         } else {
 147                 ri = malloc(sizeof(struct rasops_info), M_DEVBUF,
 148                     M_NOWAIT | M_ZERO);
 149                 if (ri == NULL) {
 150                         printf(":can't allocate rasops memory\n");
 151                         return;
 152                 }
 153                 ga = malloc(sizeof(struct ga), M_DEVBUF, M_NOWAIT | M_ZERO);
 154                 if (ga == NULL) {
 155                         printf(":can't allocate ga memory\n");
 156                         return;
 157                 }
 158                 ga->reg_paddr = sa->sa_addr2;
 159                 ga->flags = sa->sa_flags;
 160                 fb_pmap_enter(sa->sa_addr1, sa->sa_addr2,
 161                     &memva, &regva);
 162                 ri->ri_bits = (void *)memva;
 163                 ga->reg_addr = regva;
 164                 fb_common_init(ri, ga);
 165                 sc->sc_ri = ri;
 166                 sc->sc_ga = ga;
 167         }
 168
 169         wa.console = console;
 170         wa.scrdata = &_fb_screen_list;
 171         wa.accessops = &_fb_accessops;
 172         wa.accesscookie = (void *)sc;
 173
 174         config_found(self, &wa, wsdisplaydevprint);
 175 }
 176
 177 void
 178 fb_common_init(struct rasops_info *ri, struct ga *ga)
 179 {
 180         int ga_active, cookie;
 181
 182         /* XXX */
 183         ga_active = 0;
 184         if (ga->flags == 0x0000 || ga->flags == 0x0001)
 185                 ga_active = ga_init(ga);
 186
 187         /*
 188          * TR2 IPL CLUT.
 189          * 0     black
 190          * 1     red
 191          * 2     green
 192          * 4     blue
 193          * 8     yellow
 194          * 16    cyan
 195          * 32    magenta
 196          * 64    light gray
 197          * 128   dark gray
 198          * 255   white
 199          * other black
 200          * When CLUT isn't initialized for NetBSD, use black-red pair.
 201          */
 202         ri->ri_flg = RI_CENTER | RI_CLEAR;
 203         if (!ga_active)
 204                 ri->ri_flg |= RI_FORCEMONO;
 205
 206         ri->ri_depth = 8;
 207         ri->ri_width = 1280;
 208         ri->ri_height = 1024;
 209         ri->ri_stride = 2048;
 210         ri->ri_hw = (void *)ga;
 211
 212         wsfont_init();
 213         /* prefer 12 pixel wide font */
 214         cookie = wsfont_find(NULL, 12, 0, 0, 0, 0);
 215         if (cookie <= 0)
 216                 cookie = wsfont_find(NULL, 0, 0, 0, 0, 0);
 217         if (cookie <= 0) {
 218                 printf("sfb: font table is empty\n");
 219                 return;
 220         }
 221
 222         if (wsfont_lock(cookie, &ri->ri_font)) {
 223                 printf("fb: can't lock font\n");
 224                 return;
 225         }
 226         ri->ri_wsfcookie = cookie;
 227
 228         rasops_init(ri, 34, 80);
 229
 230 #if 0
 231         /* XXX no accelarated functions yet */
 232         ri->ri_ops.putchar = xxx_putchar;
 233         ri->ri_ops.erasecols = xxx_erasecols;
 234         ri->ri_ops.copyrows = xxx_copyrows;
 235         ri->ri_ops.eraserows = xxx_eraserows;
 236         ir->ri_do_cursor = xxx_do_cursor;
 237 #endif
 238
 239         /* XXX shouldn't be global */
 240         _fb_std_screen.nrows = ri->ri_rows;
 241         _fb_std_screen.ncols = ri->ri_cols;
 242         _fb_std_screen.textops = &ri->ri_ops;
 243         _fb_std_screen.capabilities = ri->ri_caps;
 244 }
 245
 246 int
 247 fb_sbdio_cnattach(uint32_t mem, uint32_t reg, int flags)
 248 {
 249         struct rasops_info *ri;
 250         struct ga *ga;
 251         vaddr_t memva, regva;
 252         long defattr;
 253
 254         ri = &fb_console_ri;
 255         ga = &fb_console_ga;
 256
 257         ga->reg_paddr = reg;
 258         ga->flags = flags;
 259         fb_pmap_enter((paddr_t)mem, (paddr_t)reg, &memva, &regva);
 260         ri->ri_bits = (void *)memva;
 261         ga->reg_addr = regva;
 262
 263         fb_common_init(ri, ga);
 264
 265         (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr);
 266         wsdisplay_cnattach(&_fb_std_screen, ri, 0, 0, defattr);
 267         fb_consaddr = mem;
 268
 269         return 0;
 270 }
 271
 272 int
 273 _fb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, struct lwp *l)
 274 {
 275         struct fb_softc *sc = v;
 276         struct wsdisplay_fbinfo *fbinfo = (void *)data;
 277         struct wsdisplay_cmap *cmap = (void *)data;
 278         struct rasops_info *ri = sc->sc_ri;
 279         struct ga *ga = sc->sc_ga;
 280         int i;
 281
 282         switch (cmd) {
 283         case WSDISPLAYIO_GTYPE:
 284                 *(uint32_t *)data = WSDISPLAY_TYPE_UNKNOWN;
 285                 return 0;
 286
 287         case WSDISPLAYIO_GINFO:
 288                 fbinfo->height = ri->ri_height;
 289                 fbinfo->width  = ri->ri_width;
 290                 fbinfo->depth  = ri->ri_depth;
 291                 fbinfo->cmsize = 256;
 292                 return 0;
 293
 294 #if 1
 295         case WSDISPLAYIO_LINEBYTES:
 296                 *(u_int *)data = ri->ri_stride;
 297                 return 0;
 298
 299 #endif
 300         case WSDISPLAYIO_GETCMAP:
 301                 if (ri->ri_flg == RI_FORCEMONO)
 302                         break;
 303                 ga_clut_get(ga);
 304                 for (i = 0; i < cmap->count; i++) {
 305                         cmap->red[i] = ga->clut[cmap->index + i][0];
 306                         cmap->green[i] = ga->clut[cmap->index + i][1];
 307                         cmap->blue[i] = ga->clut[cmap->index + i][2];
 308                 }
 309                 return 0;
 310
 311         case WSDISPLAYIO_PUTCMAP:
 312                 if (ri->ri_flg == RI_FORCEMONO)
 313                         break;
 314                 for (i = 0; i < cmap->count; i++) {
 315                         ga->clut[cmap->index + i][0] = cmap->red[i];
 316                         ga->clut[cmap->index + i][1] = cmap->green[i];
 317                         ga->clut[cmap->index + i][2] = cmap->blue[i];
 318                 }
 319                 ga_clut_set(ga);
 320                 return 0;
 321         }
 322
 323         return EPASSTHROUGH;
 324 }
 325
 326 paddr_t
 327 _fb_mmap(void *v, void *vs, off_t offset, int prot)
 328 {
 329
 330         if (offset < 0 || offset >= GA_FRB_SIZE)
 331                 return -1;
 332
 333         return mips_btop(GA_FRB_ADDR + offset);
 334 }
 335
 336 int
 337 _fb_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookie,
 338     int *curx, int *cury, long *attr)
 339 {
 340         struct fb_softc *sc = v;
 341         struct rasops_info *ri = sc->sc_ri;
 342         long defattr;
 343
 344 #if 0
 345         if (sc->sc_nscreens > 0)
 346                 return ENOMEM;
 347 #endif
 348
 349         *cookie = ri;
 350         *curx = *cury = 0;
 351         ri->ri_ops.allocattr(ri, 0, 0, 0, &defattr);
 352         *attr = defattr;
 353         sc->sc_nscreens++;
 354
 355         return 0;
 356 }
 357
 358 void
 359 _fb_free_screen(void *v, void *cookie)
 360 {
 361         struct fb_softc *sc = v;
 362
 363         sc->sc_nscreens--;
 364 }
 365
 366 int
 367 _fb_show_screen(void *v, void *cookie, int waitok,
 368     void (*cb)(void *, int, int), void *cbarg)
 369 {
 370
 371         return 0;
 372 }
 373
 374 void
 375 _fb_pollc(void *v, int on)
 376 {
 377
 378         /* no interrupt used. */
 379 }
 380
 381 void
 382 fb_pmap_enter(paddr_t fb_paddr, paddr_t reg_paddr,
 383     vaddr_t *fb_vaddr, vaddr_t *reg_vaddr)
 384 {
 385 #ifdef WIRED_FB_TLB     /* Make wired 16MPage for frame buffer */
 386         vaddr_t va;
 387         vsize_t fb_off, reg_off, pgsize;
 388
 389         pgsize = MIPS3_WIRED_SIZE;
 390         fb_off  = fb_paddr  & MIPS3_WIRED_OFFMASK;
 391         reg_off = reg_paddr & MIPS3_WIRED_OFFMASK;
 392         fb_paddr  = fb_paddr  & ~MIPS3_WIRED_OFFMASK;
 393         reg_paddr = reg_paddr & ~MIPS3_WIRED_OFFMASK;
 394         va = GA_FRB_ADDR;
 395
 396         if (mips3_wired_enter_page(va, fb_paddr, pgsize) == false) {
 397                 printf("cannot allocate fb memory\n");
 398                 return;
 399         }
 400
 401         if (mips3_wired_enter_page(va + pgsize, reg_paddr, pgsize) == false) {
 402                 printf("cannot allocate fb register\n");
 403                 return;
 404         }
 405
 406         *fb_vaddr  = va + fb_off;
 407         *reg_vaddr = va + pgsize + reg_off;
 408 #else /* WIRED_FB_TLB */
 409         paddr_t pa, epa;
 410         vaddr_t va, tva;
 411
 412         pa = addr;
 413         epa = pa + size;
 414
 415         va = uvm_km_alloc(kernel_map, epa - pa, 0, UVM_KMF_VAONLY);
 416         if (va == 0)
 417                 for (;;)
 418                         ROM_MONITOR();
 419
 420         for (tva = va; pa < epa; pa += PAGE_SIZE, tva += PAGE_SIZE)
 421                 pmap_kenter_pa(tva, pa, VM_PROT_READ | VM_PROT_WRITE, 0);
 422
 423         pmap_update(pmap_kernel());
 424
 425         *fb_vaddr  = va;
 426 #endif /* WIRED_FB_TLB */
 427 }