sys/dev/video/fb/fb.c

   1 /*-
   2  * (MPSAFE)
   3  *
   4  * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer as
  12  *    the first lines of this file unmodified.
  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  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * $FreeBSD: src/sys/dev/fb/fb.c,v 1.11.2.2 2000/08/02 22:35:22 peter Exp $
  31  */
  32
  33 #include "opt_fb.h"
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/conf.h>
  38 #include <sys/bus.h>
  39 #include <sys/kernel.h>
  40 #include <sys/malloc.h>
  41 #include <sys/uio.h>
  42 #include <sys/fbio.h>
  43 #include <sys/linker_set.h>
  44 #include <sys/device.h>
  45 #include <sys/thread2.h>
  46
  47 #include <vm/vm.h>
  48 #include <vm/pmap.h>
  49
  50 #include "fbreg.h"
  51
  52 SET_DECLARE(videodriver_set, const video_driver_t);
  53
  54 /* local arrays */
  55
  56 /*
  57  * We need at least one entry each in order to initialize a video card
  58  * for the kernel console.  The arrays will be increased dynamically
  59  * when necessary.
  60  */
  61
  62 static int              vid_malloc;
  63 static int              adapters = 1;
  64 static video_adapter_t  *adp_ini;
  65 static video_adapter_t  **adapter = &adp_ini;
  66 static video_switch_t   *vidsw_ini;
  67        video_switch_t   **vidsw = &vidsw_ini;
  68
  69 #ifdef FB_INSTALL_CDEV
  70 static cdev_t   vidcdevsw_ini;
  71 static cdev_t   *vidcdevsw = &vidcdevsw_ini;
  72 #endif
  73
  74 #define ARRAY_DELTA     4
  75
  76 static int
  77 vid_realloc_array(void)
  78 {
  79         video_adapter_t **new_adp;
  80         video_switch_t **new_vidsw;
  81 #ifdef FB_INSTALL_CDEV
  82         cdev_t *new_cdevsw;
  83 #endif
  84         int newsize;
  85
  86         if (!vid_malloc)
  87                 return ENOMEM;
  88
  89         crit_enter();
  90         newsize = ((adapters + ARRAY_DELTA)/ARRAY_DELTA)*ARRAY_DELTA;
  91         new_adp = kmalloc(sizeof(*new_adp)*newsize, M_DEVBUF, M_WAITOK | M_ZERO);
  92         new_vidsw = kmalloc(sizeof(*new_vidsw)*newsize, M_DEVBUF,
  93             M_WAITOK | M_ZERO);
  94 #ifdef FB_INSTALL_CDEV
  95         new_cdevsw = kmalloc(sizeof(*new_cdevsw)*newsize, M_DEVBUF,
  96             M_WAITOK | M_ZERO);
  97 #endif
  98         bcopy(adapter, new_adp, sizeof(*adapter)*adapters);
  99         bcopy(vidsw, new_vidsw, sizeof(*vidsw)*adapters);
 100 #ifdef FB_INSTALL_CDEV
 101         bcopy(vidcdevsw, new_cdevsw, sizeof(*vidcdevsw)*adapters);
 102 #endif
 103         if (adapters > 1) {
 104                 kfree(adapter, M_DEVBUF);
 105                 kfree(vidsw, M_DEVBUF);
 106 #ifdef FB_INSTALL_CDEV
 107                 kfree(vidcdevsw, M_DEVBUF);
 108 #endif
 109         }
 110         adapter = new_adp;
 111         vidsw = new_vidsw;
 112 #ifdef FB_INSTALL_CDEV
 113         vidcdevsw = new_cdevsw;
 114 #endif
 115         adapters = newsize;
 116         crit_exit();
 117
 118         if (bootverbose)
 119                 kprintf("fb: new array size %d\n", adapters);
 120
 121         return 0;
 122 }
 123
 124 static void
 125 vid_malloc_init(void *arg)
 126 {
 127         vid_malloc = TRUE;
 128 }
 129
 130 SYSINIT(vid_mem, SI_BOOT1_POST, SI_ORDER_ANY, vid_malloc_init, NULL);
 131
 132 /*
 133  * Low-level frame buffer driver functions
 134  * frame buffer subdrivers, such as the VGA driver, call these functions
 135  * to initialize the video_adapter structure and register it to the virtual
 136  * frame buffer driver `fb'.
 137  */
 138
 139 /* initialize the video_adapter_t structure */
 140 void
 141 vid_init_struct(video_adapter_t *adp, char *name, int type, int unit)
 142 {
 143         adp->va_flags = 0;
 144         adp->va_name = name;
 145         adp->va_type = type;
 146         adp->va_unit = unit;
 147 }
 148
 149 /* Register a video adapter */
 150 int
 151 vid_register(video_adapter_t *adp)
 152 {
 153         const video_driver_t **list;
 154         const video_driver_t *p;
 155         int index;
 156
 157         for (index = 0; index < adapters; ++index) {
 158                 if (adapter[index] == NULL)
 159                         break;
 160         }
 161         if (index >= adapters) {
 162                 if (vid_realloc_array())
 163                         return -1;
 164         }
 165
 166         adp->va_index = index;
 167         adp->va_token = NULL;
 168         lwkt_gettoken(&tty_token);
 169         SET_FOREACH(list, videodriver_set) {
 170                 p = *list;
 171                 if (strcmp(p->name, adp->va_name) == 0) {
 172                         adapter[index] = adp;
 173                         vidsw[index] = p->vidsw;
 174                         lwkt_reltoken(&tty_token);
 175                         return index;
 176                 }
 177         }
 178
 179         lwkt_reltoken(&tty_token);
 180         return -1;
 181 }
 182
 183 int
 184 vid_unregister(video_adapter_t *adp)
 185 {
 186         lwkt_gettoken(&tty_token);
 187         if ((adp->va_index < 0) || (adp->va_index >= adapters)) {
 188                 lwkt_reltoken(&tty_token);
 189                 return ENOENT;
 190         }
 191         if (adapter[adp->va_index] != adp) {
 192                 lwkt_reltoken(&tty_token);
 193                 return ENOENT;
 194         }
 195
 196         adapter[adp->va_index] = NULL;
 197         vidsw[adp->va_index] = NULL;
 198         lwkt_reltoken(&tty_token);
 199         return 0;
 200 }
 201
 202 /* Get video I/O function table */
 203 video_switch_t *
 204 vid_get_switch(char *name)
 205 {
 206         const video_driver_t **list;
 207         const video_driver_t *p;
 208
 209         lwkt_gettoken(&tty_token);
 210         SET_FOREACH(list, videodriver_set) {
 211                 p = *list;
 212                 if (strcmp(p->name, name) == 0) {
 213                         lwkt_reltoken(&tty_token);
 214                         return p->vidsw;
 215                 }
 216         }
 217
 218         lwkt_reltoken(&tty_token);
 219         return NULL;
 220 }
 221
 222 /*
 223  * Video card client functions
 224  * Video card clients, such as the console driver `syscons' and the frame
 225  * buffer cdev driver, use these functions to claim and release a card for
 226  * exclusive use.
 227  */
 228
 229 /* find the video card specified by a driver name and a unit number */
 230 int
 231 vid_find_adapter(char *driver, int unit)
 232 {
 233         int i;
 234
 235         for (i = 0; i < adapters; ++i) {
 236                 if (adapter[i] == NULL)
 237                         continue;
 238                 if (strcmp("*", driver) && strcmp(adapter[i]->va_name, driver))
 239                         continue;
 240                 if ((unit != -1) && (adapter[i]->va_unit != unit))
 241                         continue;
 242                 return i;
 243         }
 244         return -1;
 245 }
 246
 247 /* allocate a video card */
 248 int
 249 vid_allocate(char *driver, int unit, void *id)
 250 {
 251         int index;
 252
 253         crit_enter();
 254         index = vid_find_adapter(driver, unit);
 255         if (index >= 0) {
 256                 if (adapter[index]->va_token) {
 257                         crit_exit();
 258                         return -1;
 259                 }
 260                 adapter[index]->va_token = id;
 261         }
 262         crit_exit();
 263         return index;
 264 }
 265
 266 int
 267 vid_release(video_adapter_t *adp, void *id)
 268 {
 269         int error;
 270
 271         crit_enter();
 272         if (adp->va_token == NULL) {
 273                 error = EINVAL;
 274         } else if (adp->va_token != id) {
 275                 error = EPERM;
 276         } else {
 277                 adp->va_token = NULL;
 278                 error = 0;
 279         }
 280         crit_exit();
 281         return error;
 282 }
 283
 284 /* Get a video adapter structure */
 285 video_adapter_t *
 286 vid_get_adapter(int index)
 287 {
 288         if ((index < 0) || (index >= adapters))
 289                 return NULL;
 290         return adapter[index];
 291 }
 292
 293 /* Configure drivers: this is a backdoor for the console driver XXX */
 294 int
 295 vid_configure(int flags)
 296 {
 297         const video_driver_t **list;
 298         const video_driver_t *p;
 299
 300         SET_FOREACH(list, videodriver_set) {
 301                 p = *list;
 302                 if (p->configure != NULL)
 303                         (*p->configure)(flags);
 304         }
 305
 306         return 0;
 307 }
 308
 309 /*
 310  * Virtual frame buffer cdev driver functions
 311  * The virtual frame buffer driver dispatches driver functions to
 312  * appropriate subdrivers.
 313  */
 314
 315 #define FB_DRIVER_NAME  "fb"
 316
 317 #ifdef FB_INSTALL_CDEV
 318
 319 #if experimental
 320
 321 static devclass_t       fb_devclass;
 322
 323 static int              fbprobe(device_t dev);
 324 static int              fbattach(device_t dev);
 325
 326 static device_method_t fb_methods[] = {
 327         DEVMETHOD(device_probe,         fbprobe),
 328         DEVMETHOD(device_attach,        fbattach),
 329
 330         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 331         { 0, 0 }
 332 };
 333
 334 static driver_t fb_driver = {
 335         FB_DRIVER_NAME,
 336         fb_methods,
 337         0,
 338 };
 339
 340 static int
 341 fbprobe(device_t dev)
 342 {
 343         int unit;
 344
 345         unit = device_get_unit(dev);
 346         if (unit >= adapters)
 347                 return ENXIO;
 348         if (adapter[unit] == NULL)
 349                 return ENXIO;
 350
 351         device_set_desc(dev, "generic frame buffer");
 352         return 0;
 353 }
 354
 355 static int
 356 fbattach(device_t dev)
 357 {
 358         kprintf("fbattach: about to attach children\n");
 359         bus_generic_attach(dev);
 360         return 0;
 361 }
 362
 363 #endif /* experimental */
 364
 365 #define FB_UNIT(dev)    minor(dev)
 366 #define FB_MKMINOR(unit) (u)
 367
 368 #if 0
 369 static d_default_t      fboperate;
 370 static d_open_t         fbopen;
 371
 372 static struct dev_ops fb_ops = {
 373         { FB_DRIVER_NAME, 0, 0 },
 374         .d_default =    fboperate,
 375         .d_open =       fbopen
 376 };
 377 #endif
 378
 379 static void
 380 vfbattach(void *arg)
 381 {
 382         static int fb_devsw_installed = FALSE;
 383
 384         if (!fb_devsw_installed) {
 385 #if 0
 386                 dev_ops_add(&fb_ops, 0, 0);
 387 #endif
 388                 fb_devsw_installed = TRUE;
 389         }
 390 }
 391
 392 PSEUDO_SET(vfbattach, fb);
 393
 394 /*
 395  *  Note: dev represents the actual video device, not the frame buffer
 396  */
 397 int
 398 fb_attach(cdev_t dev, video_adapter_t *adp)
 399 {
 400         if (adp->va_index >= adapters)
 401                 return EINVAL;
 402         if (adapter[adp->va_index] != adp)
 403                 return EINVAL;
 404
 405         crit_enter();
 406         reference_dev(dev);
 407         adp->va_minor = minor(dev);
 408         vidcdevsw[adp->va_index] = dev;
 409         crit_exit();
 410
 411         kprintf("fb%d at %s%d\n", adp->va_index, adp->va_name, adp->va_unit);
 412         return 0;
 413 }
 414
 415 /*
 416  *  Note: dev represents the actual video device, not the frame buffer
 417  */
 418 int
 419 fb_detach(cdev_t dev, video_adapter_t *adp)
 420 {
 421         if (adp->va_index >= adapters)
 422                 return EINVAL;
 423         if (adapter[adp->va_index] != adp)
 424                 return EINVAL;
 425         if (vidcdevsw[adp->va_index] != dev)
 426                 return EINVAL;
 427
 428         crit_enter();
 429         vidcdevsw[adp->va_index] = NULL;
 430         crit_exit();
 431         release_dev(dev);
 432         return 0;
 433 }
 434
 435 #if 0
 436 static int
 437 fbopen(struct dev_open_args *ap)
 438 {
 439         cdev_t dev = ap->a_head.a_dev;
 440         int unit;
 441         cdev_t fdev;
 442
 443         unit = FB_UNIT(dev);
 444         if (unit < 0 || unit >= adapters)
 445                 return ENXIO;
 446         if ((fdev = vidcdevsw[unit]) == NULL)
 447                 return ENXIO;
 448         return dev_dopen(fdev, ap->a_oflags, ap->a_devtype, ap->a_cred);
 449 }
 450
 451 static int
 452 fboperate(struct dev_generic_args *ap)
 453 {
 454         cdev_t dev = ap->a_dev;
 455         int unit;
 456         cdev_t fdev;
 457
 458         unit = FB_UNIT(dev);
 459         if ((fdev = vidcdevsw[unit]) == NULL)
 460                 return ENXIO;
 461         ap->a_dev = fdev;
 462         return dev_doperate(ap);
 463 }
 464 #endif
 465
 466 /*
 467  * Generic frame buffer cdev driver functions
 468  * Frame buffer subdrivers may call these functions to implement common
 469  * driver functions.
 470  */
 471
 472 int genfbopen(genfb_softc_t *sc, video_adapter_t *adp, int flag, int mode,
 473               struct ucred *cred)
 474 {
 475         crit_enter();
 476         if (!(sc->gfb_flags & FB_OPEN))
 477                 sc->gfb_flags |= FB_OPEN;
 478         crit_exit();
 479         return 0;
 480 }
 481
 482 int genfbclose(genfb_softc_t *sc, video_adapter_t *adp, int flag, int mode)
 483 {
 484         crit_enter();
 485         sc->gfb_flags &= ~FB_OPEN;
 486         crit_exit();
 487         return 0;
 488 }
 489
 490 int genfbread(genfb_softc_t *sc, video_adapter_t *adp, struct uio *uio,
 491               int flag)
 492 {
 493         int size;
 494         int offset;
 495         int error;
 496         int len;
 497
 498         lwkt_gettoken(&tty_token);
 499         error = 0;
 500         size = adp->va_buffer_size/adp->va_info.vi_planes;
 501         while (uio->uio_resid > 0) {
 502                 if (uio->uio_offset >= size)
 503                         break;
 504                 offset = uio->uio_offset%adp->va_window_size;
 505                 len = (int)szmin(uio->uio_resid, size - uio->uio_offset);
 506                 len = imin(len, adp->va_window_size - offset);
 507                 if (len <= 0)
 508                         break;
 509                 (*vidsw[adp->va_index]->set_win_org)(adp, uio->uio_offset);
 510                 error = uiomove((caddr_t)(adp->va_window + offset),
 511                                 (size_t)len, uio);
 512                 if (error)
 513                         break;
 514         }
 515         lwkt_reltoken(&tty_token);
 516         return error;
 517 }
 518
 519 int genfbwrite(genfb_softc_t *sc, video_adapter_t *adp, struct uio *uio,
 520                int flag)
 521 {
 522         return ENODEV;
 523 }
 524
 525 int genfbioctl(genfb_softc_t *sc, video_adapter_t *adp, u_long cmd,
 526                caddr_t arg, int flag, struct ucred *cred)
 527 {
 528         int error;
 529
 530         if (adp == NULL)        /* XXX */
 531                 return ENXIO;
 532         lwkt_gettoken(&tty_token);
 533         error = (*vidsw[adp->va_index]->ioctl)(adp, cmd, arg);
 534         if (error == ENOIOCTL)
 535                 error = ENODEV;
 536         lwkt_reltoken(&tty_token);
 537         return error;
 538 }
 539
 540 int genfbmmap(genfb_softc_t *sc, video_adapter_t *adp, vm_offset_t offset,
 541               int prot)
 542 {
 543         int error;
 544
 545         lwkt_gettoken(&tty_token);
 546         error = (*vidsw[adp->va_index]->mmap)(adp, offset, prot);
 547         lwkt_reltoken(&tty_token);
 548         return (error);
 549 }
 550
 551 #endif /* FB_INSTALL_CDEV */
 552
 553 static char *
 554 adapter_name(int type)
 555 {
 556     static struct {
 557         int type;
 558         char *name;
 559     } names[] = {
 560         { KD_MONO,      "MDA" },
 561         { KD_HERCULES,  "Hercules" },
 562         { KD_CGA,       "CGA" },
 563         { KD_EGA,       "EGA" },
 564         { KD_VGA,       "VGA" },
 565         { KD_TGA,       "TGA" },
 566         { -1,           "Unknown" },
 567     };
 568     int i;
 569
 570     for (i = 0; names[i].type != -1; ++i)
 571         if (names[i].type == type)
 572             break;
 573     return names[i].name;
 574 }
 575
 576 /*
 577  * Generic low-level frame buffer functions
 578  * The low-level functions in the frame buffer subdriver may use these
 579  * functions.
 580  */
 581
 582 void
 583 fb_dump_adp_info(char *driver, video_adapter_t *adp, int level)
 584 {
 585     if (level <= 0)
 586         return;
 587
 588     kprintf("%s%d: %s%d, %s, type:%s (%d), flags:0x%x\n",
 589            FB_DRIVER_NAME, adp->va_index, driver, adp->va_unit, adp->va_name,
 590            adapter_name(adp->va_type), adp->va_type, adp->va_flags);
 591     kprintf("%s%d: port:0x%x-0x%x, mem:0x%x 0x%x\n",
 592            FB_DRIVER_NAME, adp->va_index,
 593            adp->va_io_base, adp->va_io_base + adp->va_io_size - 1,
 594            adp->va_mem_base, adp->va_mem_size);
 595     kprintf("%s%d: init mode:%d, bios mode:%d, current mode:%d\n",
 596            FB_DRIVER_NAME, adp->va_index,
 597            adp->va_initial_mode, adp->va_initial_bios_mode, adp->va_mode);
 598     kprintf("%s%d: window:%p size:%dk gran:%dk, buf:%p size:%dk\n",
 599            FB_DRIVER_NAME, adp->va_index,
 600            (void *)adp->va_window, (int)adp->va_window_size/1024,
 601            (int)adp->va_window_gran/1024, (void *)adp->va_buffer,
 602            (int)adp->va_buffer_size/1024);
 603 }
 604
 605 void
 606 fb_dump_mode_info(char *driver, video_adapter_t *adp, video_info_t *info,
 607                   int level)
 608 {
 609     if (level <= 0)
 610         return;
 611
 612     kprintf("%s%d: %s, mode:%d, flags:0x%x ",
 613            driver, adp->va_unit, adp->va_name, info->vi_mode, info->vi_flags);
 614     if (info->vi_flags & V_INFO_GRAPHICS)
 615         kprintf("G %dx%dx%d, %d plane(s), font:%dx%d, ",
 616                info->vi_width, info->vi_height,
 617                info->vi_depth, info->vi_planes,
 618                info->vi_cwidth, info->vi_cheight);
 619     else
 620         kprintf("T %dx%d, font:%dx%d, ",
 621                info->vi_width, info->vi_height,
 622                info->vi_cwidth, info->vi_cheight);
 623     kprintf("win:0x%x\n", info->vi_window);
 624 }
 625
 626 int
 627 fb_type(int adp_type)
 628 {
 629         static struct {
 630                 int     fb_type;
 631                 int     va_type;
 632         } types[] = {
 633                 { FBTYPE_MDA,           KD_MONO },
 634                 { FBTYPE_HERCULES,      KD_HERCULES },
 635                 { FBTYPE_CGA,           KD_CGA },
 636                 { FBTYPE_EGA,           KD_EGA },
 637                 { FBTYPE_VGA,           KD_VGA },
 638                 { FBTYPE_TGA,           KD_TGA },
 639         };
 640         int i;
 641
 642         for (i = 0; i < NELEM(types); ++i) {
 643                 if (types[i].va_type == adp_type)
 644                         return types[i].fb_type;
 645         }
 646         return -1;
 647 }
 648
 649 int
 650 fb_commonioctl(video_adapter_t *adp, u_long cmd, caddr_t arg)
 651 {
 652         int error;
 653
 654         /* assert(adp != NULL) */
 655
 656         error = 0;
 657         crit_enter();
 658
 659         lwkt_gettoken(&tty_token);
 660         switch (cmd) {
 661
 662         case FBIO_ADAPTER:      /* get video adapter index */
 663                 *(int *)arg = adp->va_index;
 664                 break;
 665
 666         case FBIO_ADPTYPE:      /* get video adapter type */
 667                 *(int *)arg = adp->va_type;
 668                 break;
 669
 670         case FBIO_ADPINFO:      /* get video adapter info */
 671                 ((video_adapter_info_t *)arg)->va_index = adp->va_index;
 672                 ((video_adapter_info_t *)arg)->va_type = adp->va_type;
 673                 bcopy(adp->va_name, ((video_adapter_info_t *)arg)->va_name,
 674                       imin(strlen(adp->va_name) + 1,
 675                            sizeof(((video_adapter_info_t *)arg)->va_name)));
 676                 ((video_adapter_info_t *)arg)->va_unit = adp->va_unit;
 677                 ((video_adapter_info_t *)arg)->va_flags = adp->va_flags;
 678                 ((video_adapter_info_t *)arg)->va_io_base = adp->va_io_base;
 679                 ((video_adapter_info_t *)arg)->va_io_size = adp->va_io_size;
 680                 ((video_adapter_info_t *)arg)->va_mem_base = adp->va_mem_base;
 681                 ((video_adapter_info_t *)arg)->va_mem_size = adp->va_mem_size;
 682                 ((video_adapter_info_t *)arg)->va_window
 683 #ifdef __i386__
 684                         = vtophys(adp->va_window);
 685 #else
 686                         = adp->va_window;
 687 #endif
 688                 ((video_adapter_info_t *)arg)->va_window_size
 689                         = adp->va_window_size;
 690                 ((video_adapter_info_t *)arg)->va_window_gran
 691                         = adp->va_window_gran;
 692                 ((video_adapter_info_t *)arg)->va_window_orig
 693                         = adp->va_window_orig;
 694                 ((video_adapter_info_t *)arg)->va_unused0
 695 #ifdef __i386__
 696                         = (adp->va_buffer) ? vtophys(adp->va_buffer) : 0;
 697 #else
 698                         = adp->va_buffer;
 699 #endif
 700                 ((video_adapter_info_t *)arg)->va_buffer_size
 701                         = adp->va_buffer_size;
 702                 ((video_adapter_info_t *)arg)->va_mode = adp->va_mode;
 703                 ((video_adapter_info_t *)arg)->va_initial_mode
 704                         = adp->va_initial_mode;
 705                 ((video_adapter_info_t *)arg)->va_initial_bios_mode
 706                         = adp->va_initial_bios_mode;
 707                 ((video_adapter_info_t *)arg)->va_line_width
 708                         = adp->va_line_width;
 709                 ((video_adapter_info_t *)arg)->va_disp_start.x
 710                         = adp->va_disp_start.x;
 711                 ((video_adapter_info_t *)arg)->va_disp_start.y
 712                         = adp->va_disp_start.y;
 713                 break;
 714
 715         case FBIO_MODEINFO:     /* get mode information */
 716                 error = (*vidsw[adp->va_index]->get_info)(adp,
 717                                 ((video_info_t *)arg)->vi_mode,
 718                                 (video_info_t *)arg);
 719                 if (error)
 720                         error = ENODEV;
 721                 break;
 722
 723         case FBIO_FINDMODE:     /* find a matching video mode */
 724                 error = (*vidsw[adp->va_index]->query_mode)(adp,
 725                                 (video_info_t *)arg);
 726                 break;
 727
 728         case FBIO_GETMODE:      /* get video mode */
 729                 *(int *)arg = adp->va_mode;
 730                 break;
 731
 732         case FBIO_SETMODE:      /* set video mode */
 733                 error = (*vidsw[adp->va_index]->set_mode)(adp, *(int *)arg);
 734                 if (error)
 735                         error = ENODEV; /* EINVAL? */
 736                 break;
 737
 738         case FBIO_GETWINORG:    /* get frame buffer window origin */
 739                 *(u_int *)arg = adp->va_window_orig;
 740                 break;
 741
 742         case FBIO_GETDISPSTART: /* get display start address */
 743                 ((video_display_start_t *)arg)->x = adp->va_disp_start.x;
 744                 ((video_display_start_t *)arg)->y = adp->va_disp_start.y;
 745                 break;
 746
 747         case FBIO_GETLINEWIDTH: /* get scan line width in bytes */
 748                 *(u_int *)arg = adp->va_line_width;
 749                 break;
 750
 751         case FBIO_GETPALETTE:   /* get color palette */
 752         case FBIO_SETPALETTE:   /* set color palette */
 753                 /* XXX */
 754
 755         case FBIOPUTCMAP:
 756         case FBIOGETCMAP:
 757                 /* XXX */
 758
 759         case FBIO_SETWINORG:    /* set frame buffer window origin */
 760         case FBIO_SETDISPSTART: /* set display start address */
 761         case FBIO_SETLINEWIDTH: /* set scan line width in pixel */
 762
 763         case FBIOGTYPE:
 764         case FBIOGATTR:
 765         case FBIOSVIDEO:
 766         case FBIOGVIDEO:
 767         case FBIOSCURSOR:
 768         case FBIOGCURSOR:
 769         case FBIOSCURPOS:
 770         case FBIOGCURPOS:
 771         case FBIOGCURMAX:
 772
 773         default:
 774                 error = ENODEV;
 775                 break;
 776         }
 777
 778         crit_exit();
 779         lwkt_reltoken(&tty_token);
 780         return error;
 781 }