| WSDISPLAY(4) | Device Drivers Manual | WSDISPLAY(4) | 
wsdisplay —
wsdisplay* at ega? console ? (EGA display on ISA)
wsdisplay* at vga? console ? (VGA display on ISA or PCI)
wsdisplay* at pcdisplay? console ? (generic PC (ISA)
  display)
wsdisplay* at tga? console ? (DEC TGA display, alpha
  only)
wsdisplay* at pfb? console ? (PCI framebuffer, bebox
  only)
wsdisplay0 at ofb? console ? (Open Firmware framebuffer,
  macppc only)
wsdisplay* at nextdisplay? console ? (NeXT display)
wsdisplay0 at smg0 (VAXstation small monochrome display)
wsdisplay* at ... kbdmux N
  
  options WSDISPLAY_BORDER_COLOR=WSCOL_XXX
  
  options WSDISPLAY_CUSTOM_BORDER
  
  options WSDISPLAY_CUSTOM_OUTPUT
  
  options WSDISPLAY_DEFAULTSCREENS=N
  
  options WSDISPLAY_SCROLLSUPPORT
wsdisplay driver is an abstraction layer for display
  devices within the wscons(4)
  framework. It attaches to the hardware specific display device driver and
  makes it available as a text terminal or graphics interface.
A display device can have the ability to display characters on it
    (without the help of an X server), either directly by hardware or through
    software putting pixel data into the display memory. Such displays are
    called “emulating”, the wsdisplay
    driver will connect a terminal emulation module and provide a tty-like
    software interface. In contrary, non-emulating displays can only be used by
    special programs like X servers.
The console locator in the configuration
    line refers to the device's use as the output part of the operating system
    console. A device specification containing a positive value here will only
    match if the device is in use as the system console. (The console device
    selection in early system startup is not influenced.) This way, the console
    device can be connected to a known wsdisplay device instance. (Naturally,
    only “emulating” display devices are usable as console.)
The kbdmux locator in the configuration
    line refers to the wsmux(4)
    that will be used to get keyboard events. If this locator is -1 no mux will
    be used.
The logical unit of an independent contents displayed on a display
    (sometimes referred to as “virtual terminal”) is called a
    “screen” here. If the underlying device driver supports it,
    multiple screens can be used on one display. (As of this writing, only the
    vga(4) and the VAX
    “smg” display drivers provide this ability.) Screens have
    different minor device numbers and separate tty instances. One screen
    possesses the “focus”, this means it is visible and its tty
    device will get the keyboard input. (In some cases - if no screen is set up
    or if a screen was just deleted - it is possible that no focus is present at
    all.) The focus can be switched by either special keyboard input (typically
    ⟨Ctrl⟩⟨Alt⟩⟨Fn⟩,
    ⟨Stop⟩⟨Fn⟩ on Sun
    hardware, ⟨Command⟩⟨Fn⟩ on
    ADB keyboards) or an ioctl command issued by a user program. Screens are
    created and deleted through the /dev/ttyEcfg control
    device (preferably using the
    wsconscfg(8) utility).
    Alternatively, the compile-time option
    WSDISPLAY_DEFAULTSCREENS=n
    will also create (at autoconfiguration time) n initial
    screens of the display driver's default type with the system's default
    terminal emulator.
wsdisplay driver:
options WSDISPLAY_BORDER_COLOR=WSCOL_XXXWSCOL_BLACK.options WSDISPLAY_CUSTOM_BORDERWSDISPLAYIO_GBORDER and
      WSDISPLAYIO_SBORDER ioctls, which allow the
      customization of the border color from userland (after boot). See
      wsconsctl(8).options WSDISPLAY_CUSTOM_OUTPUTWSDISPLAYIO_GMSGATTRS and
      WSDISPLAYIO_SMSGATTRS ioctls, which allow the
      customization of the console output and kernel messages from userland
      (after boot). See
      wsconsctl(8).options WSDISPLAY_DEFAULTSCREENS=Noptions WSDISPLAY_SCROLLSUPPORTwsdisplay driver or by devices which
  use it. Their definitions are found in
  <dev/wscons/wsconsio.h>.
WSDISPLAYIO_GTYPE
    (int)<dev/wscons/wsconsio.h>.WSDISPLAYIO_GET_FBINFO
    (struct wsdisplayio_fbinfo)
struct wsdisplayio_fbinfo {
	uint64_t fbi_fbsize;
	uint64_t fbi_fboffset;
	uint32_t fbi_width;
	uint32_t fbi_height;
	uint32_t fbi_stride;
	uint32_t fbi_bitsperpixel;
	uint32_t fbi_pixeltype;
	union _fbi_subtype {
		struct _fbi_rgbmasks {
			uint32_t red_offset;
			uint32_t red_size;
			uint32_t green_offset;
			uint32_t green_size;
			uint32_t blue_offset;
			uint32_t blue_size;
			uint32_t alpha_offset;
			uint32_t alpha_size;
		} fbi_rgbmasks;
		struct _fbi_cmapinfo {
			uint32_t cmap_entries;
		} fbi_cmapinfo;
	} fbi_subtype;
	uint32_t fbi_flags;
};
    
    For a "true colour" display, the
        fbi_pixeltype field contains
        WSFB_RGB and the
        fbi_rgbmasks field contains the pixel packing
        layout. For a colour indexed display, the
        fbi_pixeltype field contains
        WSFB_CI and the
        fbi_cmapinfo field contains the number of color
        map entries.
WSDISPLAYIO_GINFO
    (struct wsdisplay_fbinfo)
struct wsdisplay_fbinfo {
	u_int	height;
	u_int	width;
	u_int	depth;
	u_int	cmsize;
};
    
    The height and
        width members are counted in pixels. The
        depth member indicates the number of bits per
        pixel, and cmsize indicates the number of color
        map entries accessible through
        WSDISPLAYIO_GETCMAP and
        WSDISPLAYIO_PUTCMAP. This call is likely to be
        unavailable on text-only displays.
WSDISPLAYIO_GETCMAP
    (struct wsdisplay_cmap)
struct wsdisplay_cmap {
	u_int	index;
	u_int	count;
	u_char	*red;
	u_char	*green;
	u_char	*blue;
};
    
    The index and count members specify the range of color map entries to retrieve. The red, green, and blue members should each point to an array of count u_chars. On return, these will be filled in with the appropriate entries from the color map. On all displays that support this call, values range from 0 for minimum intensity to 255 for maximum intensity, even if the display does not use eight bits internally to represent intensity.
WSDISPLAYIO_PUTCMAP
    (struct wsdisplay_cmap)WSDISPLAYIO_GETCMAP, but
      red, green, and
      blue are taken as pointers to the values to use to
      set the color map. This call is not available on displays with fixed color
      maps.WSDISPLAYIO_GVIDEO
    (int)WSDISPLAYIO_VIDEO_OFFWSDISPLAYIO_VIDEO_ONWSDISPLAYIO_SVIDEO
    (int)WSDISPLAYIO_GVIDEO above for possible values.WSDISPLAYIO_GCURPOS
    (struct wsdisplay_curpos)
struct wsdisplay_curpos {
        u_int x, y;
};
    
    The x and y members count the number of pixels right and down, respectively, from the top-left corner of the display to the hot spot of the cursor. This call is not available on displays without a hardware cursor.
WSDISPLAYOP_SCURPOS
    (struct wsdisplay_curpos)WSDISPLAYIO_GCURPOS. This call is not available on
      displays without a hardware cursor.WSDISPLAYIO_GCURMAX
    (struct wsdisplay_curpos)WSDISPLAYIO_GCURSOR
    (struct wsdisplay_cursor)
struct wsdisplay_cursor {
	u_int	which;
	u_int	enable;
	struct wsdisplay_curpos pos;
	struct wsdisplay_curpos hot;
	struct wsdisplay_cmap cmap;
	struct wsdisplay_curpos size;
	u_char *image;
	u_char *mask;
};
    
    WSDISPLAY_CURSOR_DOCURWSDISPLAY_CURSOR_DOPOSWSDISPLAYIO_GCURPOS.WSDISPLAY_CURSOR_DOHOTWSDISPLAY_CURSOR_DOCMAPWSDISPLAYIO_GETCMAP,
          cmap here need not have its
          index and count members
          initialized. They will be set to 0 and 2 respectively by the call.
          This means that cmap.red,
          cmap.green, and
          cmap.blue must each point
          to at least enough space to hold two
          u_chars.WSDISPLAY_CURSOR_DOSHAPEWSDISPLAY_CURSOR_DOALLThe device may elect to return information that was not
        requested by the user, so those elements of struct
        wsdisplay_cursor which are pointers should be initialized to
        NULL if not otherwise used. This call is not
        available on displays without a hardware cursor.
WSDISPLAYIO_SCURSOR
    (struct wsdisplay_cursor)WSDISPLAYIO_GCURSOR.
      The which member specifies which attributes of the
      cursor are to be changed. It should contain the logical OR of the
      following flags:
    WSDISPLAY_CURSOR_DOCURWSDISPLAY_CURSOR_DOPOSWSDISPLAYIO_SCURPOS.WSDISPLAY_CURSOR_DOHOTWSDISPLAY_CURSOR_DOCMAPWSDISPLAY_CURSOR_DOSHAPEWSDISPLAY_CURSOR_DOALLThis call is not available on displays without a hardware cursor.
WSDISPLAYIO_GMODE
    (u_int)WSDISPLAYIO_MODE_EMULWSDISPLAYIO_MODE_MAPPEDWSDISPLAYIO_MODE_DUMBFBWSDISPLAYIO_SMODE
    (u_int)WSDISPLAYIO_GMODE.WSDISPLAYIO_LINEBYTES
    (u_int)WSDISPLAYIO_GMSGATTRS
    (struct wsdisplay_msgattrs)
struct wsdisplay_msgattrs {
	int default_attrs, default_bg, default_fg;
	int kernel_attrs, kernel_bg, kernel_fg;
};
    
    The default_attrs and
        kernel_attrs variables are a combination of
        WSATTR_* bits, and specify
        the attributes used to draw messages. The
        default_bg, default_fg,
        kernel_bg and kernel_fg
        variables specify the colors used to print messages, being
        ‘_bg’ for the background and ‘_fg’ for the
        foreground; their values are one of all the
        WSCOL_* macros
      available.
WSDISPLAYIO_SMSGATTRS
    (struct wsdisplay_msgattrs)WSDISPLAYIO_GMSGATTRS.WSDISPLAYIO_GBORDER
    (u_int)WSDISPLAYIO_SBORDER
    (u_int)WSDISPLAYIO_GETWSCHAR
    (struct wsdisplay_char)
struct wsdisplay_char {
	int row, col;
	uint16_t letter;
	uint8_t background, foreground;
	char flags;
};
    
    The row and col
        parameters are used as input; the rest of the structure is filled by the
        ioctl and is returned to you. letter is the ASCII
        code of the letter found at the specified position,
        background and foreground
        are its colors and flags is a combination of
        WSDISPLAY_CHAR_BRIGHT and/or
        WSDISPLAY_CHAR_BLINK.
WSDISPLAYIO_PUTWSCHAR
    (struct wsdisplay_char)WSDISPLAY_GETWSCHAR, although all of
      its fields are treated as input.WSDISPLAYIO_SSPLASH
    (u_int)SPLASHSCREEN kernel option.WSDISPLAYIO_GET_EDID
    (struct wsdisplayio_edid_info)
struct wsdisplayio_edid_info {
	uint32_t buffer_size;
	uint32_t data_size;
	void *edid_data;
};
    
    EAGAIN and
      the driver will set data_size to the required buffer size. Otherwise the
      EDID block will be written into the buffer pointed at by edid_data and
      data_size will be set to the number of bytes written.WSDISPLAYIO_SETVERSION
    (int)WSDISPLAYIO_EVENT_VERSION, and is currently 1. All
      new code should use a call similar to the below to ensure the correct
      version is returned.
    
int ver = WSDISPLAYIO_EVENT_VERSION;
if (ioctl(fd, WSDISPLAYIO_SETVERSION, &ver) == -1)
    err(EXIT_FAILURE, "cannot set version");
    
    wsdisplay code currently limits the number of
  screens on one display to 8.
The terms “wscons” and “wsdisplay” are not cleanly distinguished in the code and in manual pages.
“non-emulating” display devices are not tested.
| May 16, 2020 | NetBSD 10.0 |