The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/fb/fb.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: b1bf000090041e1129fa8505502d1f19


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.