aboutsummaryrefslogtreecommitdiff
path: root/sys
diff options
context:
space:
mode:
Diffstat (limited to 'sys')
-rw-r--r--sys/conf/files4
-rw-r--r--sys/dev/usb/usbdevs22
-rw-r--r--sys/dev/usb/video/udl.c1068
-rw-r--r--sys/dev/usb/video/udl.h311
-rw-r--r--sys/modules/usb/udl/Makefile12
5 files changed, 1417 insertions, 0 deletions
diff --git a/sys/conf/files b/sys/conf/files
index 24e0654a3fdda..3b8c2b431ba72 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -2563,6 +2563,10 @@ dev/usb/template/usb_template_mtp.c optional usb_template
dev/usb/template/usb_template_phone.c optional usb_template
dev/usb/template/usb_template_serialnet.c optional usb_template
#
+# USB video drivers
+#
+dev/usb/video/udl.c optional udl
+#
# USB END
#
dev/videomode/videomode.c optional videomode
diff --git a/sys/dev/usb/usbdevs b/sys/dev/usb/usbdevs
index a40c913b20ad6..88aa4eb3569af 100644
--- a/sys/dev/usb/usbdevs
+++ b/sys/dev/usb/usbdevs
@@ -686,6 +686,7 @@ vendor ASUS2 0x1761 ASUS
vendor SWEEX2 0x177f Sweex
vendor METAGEEK 0x1781 MetaGeek
vendor KAMSTRUP 0x17a8 Kamstrup A/S
+vendor DISPLAYLINK 0x17e9 DisplayLink
vendor LENOVO 0x17ef Lenovo
vendor WAVESENSE 0x17f4 WaveSense
vendor VAISALA 0x1843 Vaisala
@@ -1655,6 +1656,27 @@ product DLINK2 RT3070_4 0x3c15 RT3070
product DLINK2 RT3070_5 0x3c16 RT3070
product DLINK3 DWM652 0x3e04 DWM-652
+/* DisplayLink products */
+product DISPLAYLINK LCD4300U 0x01ba LCD-4300U
+product DISPLAYLINK LCD8000U 0x01bb LCD-8000U
+product DISPLAYLINK LD220 0x0100 Samsung LD220
+product DISPLAYLINK GUC2020 0x0059 IOGEAR DVI GUC2020
+product DISPLAYLINK VCUD60 0x0136 Rextron DVI
+product DISPLAYLINK CONV 0x0138 StarTech CONV-USB2DVI
+product DISPLAYLINK DLDVI 0x0141 DisplayLink DVI
+product DISPLAYLINK VGA10 0x015a CMP-USBVGA10
+product DISPLAYLINK WSDVI 0x0198 WS Tech DVI
+product DISPLAYLINK EC008 0x019b EasyCAP008 DVI
+product DISPLAYLINK HPDOCK 0x01d4 HP USB Docking
+product DISPLAYLINK NL571 0x01d7 HP USB DVI
+product DISPLAYLINK M01061 0x01e2 Lenovo DVI
+product DISPLAYLINK SWDVI 0x024c SUNWEIT DVI
+product DISPLAYLINK NBDOCK 0x0215 VideoHome NBdock1920
+product DISPLAYLINK LUM70 0x02a9 Lilliput UM-70
+product DISPLAYLINK UM7X0 0x401a nanovision MiMo
+product DISPLAYLINK LT1421 0x03e0 Lenovo ThinkVision LT1421
+product DISPLAYLINK POLARIS2 0x0117 Polaris2 USB dock
+
/* DMI products */
product DMI CFSM_RW 0xa109 CF/SM Reader/Writer
product DMI DISK 0x2bcf Generic Disk
diff --git a/sys/dev/usb/video/udl.c b/sys/dev/usb/video/udl.c
new file mode 100644
index 0000000000000..d0a2f826a58be
--- /dev/null
+++ b/sys/dev/usb/video/udl.c
@@ -0,0 +1,1068 @@
+/* $OpenBSD: udl.c,v 1.81 2014/12/09 07:05:06 doug Exp $ */
+/* $FreeBSD$ */
+
+/*-
+ * Copyright (c) 2015 Hans Petter Selasky <hselasky@freebsd.org>
+ * Copyright (c) 2009 Marcus Glocker <mglocker@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * Driver for the "DisplayLink DL-120 / DL-160" graphic chips based on
+ * the reversed engineered specifications of Florian Echtler
+ * <floe@butterbrot.org>:
+ *
+ * http://floe.butterbrot.org/displaylink/doku.php
+ */
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/callout.h>
+#include <sys/conf.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/module.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/systm.h>
+#include <sys/consio.h>
+#include <sys/fbio.h>
+
+#include <dev/fb/fbreg.h>
+#include <dev/syscons/syscons.h>
+
+#include <dev/videomode/videomode.h>
+#include <dev/videomode/edidvar.h>
+
+#include <dev/usb/usb.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
+
+#include <dev/usb/video/udl.h>
+
+#include "fb_if.h"
+
+#undef DPRINTF
+#undef DPRINTFN
+#define USB_DEBUG_VAR udl_debug
+#include <dev/usb/usb_debug.h>
+
+#ifdef USB_DEBUG
+static int udl_debug = 0;
+
+static SYSCTL_NODE(_hw_usb, OID_AUTO, udl, CTLFLAG_RW, 0, "USB UDL");
+
+SYSCTL_INT(_hw_usb_udl, OID_AUTO, debug, CTLFLAG_RWTUN,
+ &udl_debug, 0, "Debug level");
+#endif
+
+/*
+ * Prototypes.
+ */
+static usb_callback_t udl_bulk_write_callback;
+
+static device_probe_t udl_probe;
+static device_attach_t udl_attach;
+static device_detach_t udl_detach;
+static fb_getinfo_t udl_fb_getinfo;
+#if 0
+static fb_blank_display_t udl_fb_blank_display;
+#endif
+
+static void udl_select_chip(struct udl_softc *, struct usb_attach_arg *);
+static int udl_init_chip(struct udl_softc *);
+static void udl_select_mode(struct udl_softc *);
+static int udl_init_resolution(struct udl_softc *);
+static void udl_fbmem_alloc(struct udl_softc *);
+static int udl_cmd_write_buf_le16(struct udl_softc *, const uint8_t *, uint32_t, uint8_t, int);
+static int udl_cmd_buf_copy_le16(struct udl_softc *, uint32_t, uint32_t, uint8_t, int);
+static void udl_cmd_insert_int_1(struct udl_cmd_buf *, uint8_t);
+static void udl_cmd_insert_int_3(struct udl_cmd_buf *, uint32_t);
+static void udl_cmd_insert_buf_le16(struct udl_cmd_buf *, const uint8_t *, uint32_t);
+static void udl_cmd_write_reg_1(struct udl_cmd_buf *, uint8_t, uint8_t);
+static void udl_cmd_write_reg_3(struct udl_cmd_buf *, uint8_t, uint32_t);
+#if 0
+static int udl_power_save(struct udl_softc *, int, int);
+#endif
+
+static const struct usb_config udl_config[UDL_N_TRANSFER] = {
+ [UDL_BULK_WRITE_0] = {
+ .type = UE_BULK,
+ .endpoint = UE_ADDR_ANY,
+ .direction = UE_DIR_TX,
+ .flags = {.pipe_bof = 1,.force_short_xfer = 1,.ext_buffer = 1,},
+ .bufsize = UDL_CMD_MAX_DATA_SIZE * UDL_CMD_MAX_FRAMES,
+ .callback = &udl_bulk_write_callback,
+ .frames = UDL_CMD_MAX_FRAMES,
+ .timeout = 5000, /* 5 seconds */
+ },
+ [UDL_BULK_WRITE_1] = {
+ .type = UE_BULK,
+ .endpoint = UE_ADDR_ANY,
+ .direction = UE_DIR_TX,
+ .flags = {.pipe_bof = 1,.force_short_xfer = 1,.ext_buffer = 1,},
+ .bufsize = UDL_CMD_MAX_DATA_SIZE * UDL_CMD_MAX_FRAMES,
+ .callback = &udl_bulk_write_callback,
+ .frames = UDL_CMD_MAX_FRAMES,
+ .timeout = 5000, /* 5 seconds */
+ },
+};
+
+/*
+ * Driver glue.
+ */
+static devclass_t udl_devclass;
+
+static device_method_t udl_methods[] = {
+ DEVMETHOD(device_probe, udl_probe),
+ DEVMETHOD(device_attach, udl_attach),
+ DEVMETHOD(device_detach, udl_detach),
+ DEVMETHOD(fb_getinfo, udl_fb_getinfo),
+#if 0
+ DEVMETHOD(fb_blank_display, udl_fb_blank_display),
+#endif
+ DEVMETHOD_END
+};
+
+static driver_t udl_driver = {
+ .name = "udl",
+ .methods = udl_methods,
+ .size = sizeof(struct udl_softc),
+};
+
+DRIVER_MODULE(udl, uhub, udl_driver, udl_devclass, NULL, NULL);
+MODULE_DEPEND(udl, usb, 1, 1, 1);
+MODULE_DEPEND(udl, fbd, 1, 1, 1);
+MODULE_DEPEND(udl, videomode, 1, 1, 1);
+MODULE_VERSION(udl, 1);
+
+/*
+ * Matching devices.
+ */
+static const STRUCT_USB_HOST_ID udl_devs[] = {
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LCD4300U, DL120)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LCD8000U, DL120)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_GUC2020, DL160)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LD220, DL165)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_VCUD60, DL160)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_DLDVI, DL160)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_VGA10, DL120)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_WSDVI, DLUNK)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_EC008, DL160)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_HPDOCK, DL160)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_NL571, DL160)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_M01061, DL195)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_NBDOCK, DL165)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_SWDVI, DLUNK)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_UM7X0, DL120)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_CONV, DL160)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LUM70, DL125)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_POLARIS2, DLUNK)},
+ {USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LT1421, DLUNK)}
+};
+
+static uint32_t
+udl_get_fb_size(struct udl_softc *sc)
+{
+ unsigned i = sc->sc_cur_mode;
+
+ return ((uint32_t)udl_modes[i].hdisplay *
+ (uint32_t)udl_modes[i].vdisplay * 2);
+}
+
+static uint32_t
+udl_get_fb_width(struct udl_softc *sc)
+{
+ unsigned i = sc->sc_cur_mode;
+
+ return (udl_modes[i].vdisplay);
+}
+
+static uint32_t
+udl_get_fb_height(struct udl_softc *sc)
+{
+ unsigned i = sc->sc_cur_mode;
+
+ return (udl_modes[i].hdisplay);
+}
+
+static uint32_t
+udl_get_fb_hz(struct udl_softc *sc)
+{
+ unsigned i = sc->sc_cur_mode;
+
+ return (udl_modes[i].hz);
+}
+
+static void
+udl_callout(void *arg)
+{
+ struct udl_softc *sc = arg;
+ const uint32_t max = udl_get_fb_size(sc);
+
+ if (sc->sc_power_save == 0) {
+ if (sc->sc_sync_off >= max)
+ sc->sc_sync_off = 0;
+ usbd_transfer_start(sc->sc_xfer[UDL_BULK_WRITE_0]);
+ usbd_transfer_start(sc->sc_xfer[UDL_BULK_WRITE_1]);
+ }
+ callout_reset(&sc->sc_callout, hz / 5, &udl_callout, sc);
+}
+
+static int
+udl_probe(device_t dev)
+{
+ struct usb_attach_arg *uaa = device_get_ivars(dev);
+
+ if (uaa->usb_mode != USB_MODE_HOST)
+ return (ENXIO);
+ if (uaa->info.bConfigIndex != 0)
+ return (ENXIO);
+ if (uaa->info.bIfaceIndex != 0)
+ return (ENXIO);
+
+ return (usbd_lookup_id_by_uaa(udl_devs, sizeof(udl_devs), uaa));
+}
+
+static int
+udl_attach(device_t dev)
+{
+ struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
+ struct sysctl_oid *tree = device_get_sysctl_tree(dev);
+ struct udl_softc *sc = device_get_softc(dev);
+ struct usb_attach_arg *uaa = device_get_ivars(dev);
+ int error;
+ int i;
+
+ device_set_usb_desc(dev);
+
+ mtx_init(&sc->sc_mtx, "UDL lock", NULL, MTX_DEF);
+ cv_init(&sc->sc_cv, "UDLCV");
+ callout_init_mtx(&sc->sc_callout, &sc->sc_mtx, 0);
+ sc->sc_udev = uaa->device;
+
+ error = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex,
+ sc->sc_xfer, udl_config, UDL_N_TRANSFER, sc, &sc->sc_mtx);
+
+ if (error) {
+ DPRINTF("usbd_transfer_setup error=%s\n", usbd_errstr(error));
+ goto detach;
+ }
+ usbd_xfer_set_priv(sc->sc_xfer[UDL_BULK_WRITE_0], &sc->sc_xfer_head[0]);
+ usbd_xfer_set_priv(sc->sc_xfer[UDL_BULK_WRITE_1], &sc->sc_xfer_head[1]);
+
+ TAILQ_INIT(&sc->sc_xfer_head[0]);
+ TAILQ_INIT(&sc->sc_xfer_head[1]);
+ TAILQ_INIT(&sc->sc_cmd_buf_free);
+ TAILQ_INIT(&sc->sc_cmd_buf_pending);
+
+ sc->sc_def_chip = -1;
+ sc->sc_chip = USB_GET_DRIVER_INFO(uaa);
+ sc->sc_def_mode = -1;
+ sc->sc_cur_mode = UDL_MAX_MODES;
+
+ /* Allow chip ID to be overwritten */
+ SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "chipid_force",
+ CTLFLAG_RWTUN, &sc->sc_def_chip, 0, "chip ID");
+
+ /* Export current chip ID */
+ SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "chipid",
+ CTLFLAG_RD, &sc->sc_chip, 0, "chip ID");
+
+ if (sc->sc_def_chip > -1 && sc->sc_def_chip <= DLMAX) {
+ device_printf(dev, "Forcing chip ID to 0x%04x\n", sc->sc_def_chip);
+ sc->sc_chip = sc->sc_def_chip;
+ }
+ /*
+ * The product might have more than one chip
+ */
+ if (sc->sc_chip == DLUNK)
+ udl_select_chip(sc, uaa);
+
+ for (i = 0; i != UDL_CMD_MAX_BUFFERS; i++) {
+ struct udl_cmd_buf *cb = &sc->sc_cmd_buf_temp[i];
+
+ TAILQ_INSERT_TAIL(&sc->sc_cmd_buf_free, cb, entry);
+ }
+
+ /*
+ * Initialize chip.
+ */
+ error = udl_init_chip(sc);
+ if (error != USB_ERR_NORMAL_COMPLETION)
+ goto detach;
+
+ /*
+ * Select edid mode.
+ */
+ udl_select_mode(sc);
+
+ /* Allow default mode to be overwritten */
+ SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "mode_force",
+ CTLFLAG_RWTUN, &sc->sc_def_mode, 0, "mode");
+
+ /* Export current mode */
+ SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "mode",
+ CTLFLAG_RD, &sc->sc_cur_mode, 0, "mode");
+
+ i = sc->sc_def_mode;
+ if (i > -1 && i < UDL_MAX_MODES) {
+ if (udl_modes[i].chip <= sc->sc_chip) {
+ device_printf(dev, "Forcing mode to %d\n", i);
+ sc->sc_cur_mode = i;
+ }
+ }
+ /* Printout current mode */
+ device_printf(dev, "Mode selected %dx%d @ %dHz\n",
+ (int)udl_get_fb_width(sc),
+ (int)udl_get_fb_height(sc),
+ (int)udl_get_fb_hz(sc));
+
+ udl_init_resolution(sc);
+
+ /* Allocate frame buffer */
+ udl_fbmem_alloc(sc);
+
+ UDL_LOCK(sc);
+ udl_callout(sc);
+ UDL_UNLOCK(sc);
+
+ sc->sc_fb_info.fb_name = device_get_nameunit(dev);
+ sc->sc_fb_info.fb_size = sc->sc_fb_size;
+ sc->sc_fb_info.fb_bpp = 16;
+ sc->sc_fb_info.fb_depth = 16;
+ sc->sc_fb_info.fb_width = udl_get_fb_width(sc);
+ sc->sc_fb_info.fb_height = udl_get_fb_height(sc);
+ sc->sc_fb_info.fb_stride = sc->sc_fb_info.fb_width * 2;
+ sc->sc_fb_info.fb_pbase = (uintptr_t)sc->sc_fb_addr;
+ sc->sc_fb_info.fb_vbase = (uintptr_t)sc->sc_fb_addr;
+
+ sc->sc_fbdev = device_add_child(dev, "fbd", -1);
+ if (sc->sc_fbdev == NULL)
+ goto detach;
+ if (device_probe_and_attach(sc->sc_fbdev) != 0)
+ goto detach;
+
+ return (0);
+
+detach:
+ udl_detach(dev);
+
+ return (ENXIO);
+}
+
+static int
+udl_detach(device_t dev)
+{
+ struct udl_softc *sc = device_get_softc(dev);
+
+ if (sc->sc_fbdev != NULL) {
+ device_t bdev;
+
+ bdev = sc->sc_fbdev;
+ sc->sc_fbdev = NULL;
+ device_detach(bdev);
+ device_delete_child(dev, bdev);
+ }
+ UDL_LOCK(sc);
+ sc->sc_gone = 1;
+ callout_stop(&sc->sc_callout);
+ UDL_UNLOCK(sc);
+
+ usbd_transfer_unsetup(sc->sc_xfer, UDL_N_TRANSFER);
+
+ callout_drain(&sc->sc_callout);
+
+ mtx_destroy(&sc->sc_mtx);
+ cv_destroy(&sc->sc_cv);
+
+ /*
+ * Free framebuffer memory, if any.
+ */
+ free(sc->sc_fb_addr, M_DEVBUF);
+ free(sc->sc_fb_copy, M_DEVBUF);
+
+ return (0);
+}
+
+static struct fb_info *
+udl_fb_getinfo(device_t dev)
+{
+ struct udl_softc *sc = device_get_softc(dev);
+
+ return (&sc->sc_fb_info);
+}
+
+#if 0
+static int
+udl_fb_blank_display(device_t dev, int mode)
+{
+ struct udl_softc *sc = device_get_softc(dev);
+
+ switch (mode) {
+ case V_DISPLAY_ON:
+ udl_power_save(sc, 1, M_WAITOK);
+ break;
+ case V_DISPLAY_BLANK:
+ udl_power_save(sc, 1, M_WAITOK);
+ if (sc->sc_fb_addr != 0) {
+ const uint32_t max = udl_get_fb_size(sc);
+
+ memset((void *)sc->sc_fb_addr, 0, max);
+ }
+ break;
+ case V_DISPLAY_STAND_BY:
+ case V_DISPLAY_SUSPEND:
+ udl_power_save(sc, 0, M_WAITOK);
+ break;
+ }
+ return (0);
+}
+#endif
+
+static struct udl_cmd_buf *
+udl_cmd_buf_alloc(struct udl_softc *sc, int flags)
+{
+ struct udl_cmd_buf *cb;
+
+ UDL_LOCK(sc);
+ while ((cb = TAILQ_FIRST(&sc->sc_cmd_buf_free)) == NULL) {
+ if (flags != M_WAITOK)
+ break;
+ cv_wait(&sc->sc_cv, &sc->sc_mtx);
+ }
+ if (cb != NULL) {
+ TAILQ_REMOVE(&sc->sc_cmd_buf_free, cb, entry);
+ cb->off = 0;
+ }
+ UDL_UNLOCK(sc);
+ return (cb);
+}
+
+static void
+udl_cmd_buf_send(struct udl_softc *sc, struct udl_cmd_buf *cb)
+{
+ UDL_LOCK(sc);
+ if (sc->sc_gone) {
+ TAILQ_INSERT_TAIL(&sc->sc_cmd_buf_free, cb, entry);
+ } else {
+ /* mark end of command stack */
+ udl_cmd_insert_int_1(cb, UDL_BULK_SOC);
+ udl_cmd_insert_int_1(cb, UDL_BULK_CMD_EOC);
+
+ TAILQ_INSERT_TAIL(&sc->sc_cmd_buf_pending, cb, entry);
+ usbd_transfer_start(sc->sc_xfer[UDL_BULK_WRITE_0]);
+ usbd_transfer_start(sc->sc_xfer[UDL_BULK_WRITE_1]);
+ }
+ UDL_UNLOCK(sc);
+}
+
+static struct udl_cmd_buf *
+udl_fb_synchronize(struct udl_softc *sc)
+{
+ const uint32_t max = udl_get_fb_size(sc);
+
+ while (sc->sc_sync_off < max) {
+ uint32_t delta = max - sc->sc_sync_off;
+
+ if (delta > UDL_CMD_MAX_PIXEL_COUNT * 2)
+ delta = UDL_CMD_MAX_PIXEL_COUNT * 2;
+ if (bcmp(sc->sc_fb_addr + sc->sc_sync_off, sc->sc_fb_copy + sc->sc_sync_off, delta) != 0) {
+ struct udl_cmd_buf *cb;
+
+ cb = udl_cmd_buf_alloc(sc, M_NOWAIT);
+ if (cb == NULL)
+ goto done;
+ memcpy(sc->sc_fb_copy + sc->sc_sync_off,
+ sc->sc_fb_addr + sc->sc_sync_off, delta);
+ udl_cmd_insert_int_1(cb, UDL_BULK_SOC);
+ udl_cmd_insert_int_1(cb, UDL_BULK_CMD_FB_WRITE | UDL_BULK_CMD_FB_WORD);
+ udl_cmd_insert_int_3(cb, sc->sc_sync_off);
+ udl_cmd_insert_int_1(cb, delta / 2);
+ udl_cmd_insert_buf_le16(cb, sc->sc_fb_copy + sc->sc_sync_off, delta);
+ sc->sc_sync_off += delta;
+ return (cb);
+ } else {
+ sc->sc_sync_off += delta;
+ }
+ }
+done:
+ return (NULL);
+}
+
+static void
+udl_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
+{
+ struct udl_softc *sc = usbd_xfer_softc(xfer);
+ struct udl_cmd_head *phead = usbd_xfer_get_priv(xfer);
+ struct udl_cmd_buf *cb;
+ unsigned i;
+
+ switch (USB_GET_STATE(xfer)) {
+ case USB_ST_TRANSFERRED:
+ TAILQ_CONCAT(&sc->sc_cmd_buf_free, phead, entry);
+ case USB_ST_SETUP:
+tr_setup:
+ for (i = 0; i != UDL_CMD_MAX_FRAMES; i++) {
+ cb = TAILQ_FIRST(&sc->sc_cmd_buf_pending);
+ if (cb == NULL) {
+ cb = udl_fb_synchronize(sc);
+ if (cb == NULL)
+ break;
+ }
+ TAILQ_REMOVE(&sc->sc_cmd_buf_pending, cb, entry);
+ TAILQ_INSERT_TAIL(phead, cb, entry);
+ usbd_xfer_set_frame_data(xfer, i, cb->buf, cb->off);
+ }
+ if (i != 0) {
+ usbd_xfer_set_frames(xfer, i);
+ usbd_transfer_submit(xfer);
+ }
+ break;
+ default:
+ TAILQ_CONCAT(&sc->sc_cmd_buf_free, phead, entry);
+ if (error != USB_ERR_CANCELLED) {
+ /* try clear stall first */
+ usbd_xfer_set_stall(xfer);
+ goto tr_setup;
+ }
+ break;
+ }
+ /* wakeup any waiters */
+ cv_signal(&sc->sc_cv);
+}
+
+#if 0
+static int
+udl_power_save(struct udl_softc *sc, int on, int flags)
+{
+ struct udl_cmd_buf *cb;
+
+ /* get new buffer */
+ cb = udl_cmd_buf_alloc(sc, flags);
+ if (cb == NULL)
+ return (EAGAIN);
+
+ DPRINTF("screen %s\n", on ? "ON" : "OFF");
+
+ sc->sc_power_save = on ? 0 : 1;
+
+ if (on)
+ udl_cmd_write_reg_1(cb, UDL_REG_SCREEN, UDL_REG_SCREEN_ON);
+ else
+ udl_cmd_write_reg_1(cb, UDL_REG_SCREEN, UDL_REG_SCREEN_OFF);
+
+ udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0xff);
+ udl_cmd_buf_send(sc, cb);
+ return (0);
+}
+#endif
+
+static int
+udl_ctrl_msg(struct udl_softc *sc, uint8_t rt, uint8_t r,
+ uint16_t index, uint16_t value, uint8_t *buf, size_t len)
+{
+ usb_device_request_t req;
+ int error;
+
+ req.bmRequestType = rt;
+ req.bRequest = r;
+ USETW(req.wIndex, index);
+ USETW(req.wValue, value);
+ USETW(req.wLength, len);
+
+ error = usbd_do_request_flags(sc->sc_udev, NULL,
+ &req, buf, 0, NULL, USB_DEFAULT_TIMEOUT);
+
+ DPRINTF("%s\n", usbd_errstr(error));
+
+ return (error);
+}
+
+static int
+udl_poll(struct udl_softc *sc, uint32_t *buf)
+{
+ uint32_t lbuf;
+ int error;
+
+ error = udl_ctrl_msg(sc, UT_READ_VENDOR_DEVICE,
+ UDL_CTRL_CMD_POLL, 0x0000, 0x0000, (uint8_t *)&lbuf, sizeof(lbuf));
+ if (error == USB_ERR_NORMAL_COMPLETION)
+ *buf = le32toh(lbuf);
+ return (error);
+}
+
+static int
+udl_read_1(struct udl_softc *sc, uint16_t addr, uint8_t *buf)
+{
+ uint8_t lbuf[1];
+ int error;
+
+ error = udl_ctrl_msg(sc, UT_READ_VENDOR_DEVICE,
+ UDL_CTRL_CMD_READ_1, addr, 0x0000, lbuf, 1);
+ if (error == USB_ERR_NORMAL_COMPLETION)
+ *buf = *(uint8_t *)lbuf;
+ return (error);
+}
+
+static int
+udl_write_1(struct udl_softc *sc, uint16_t addr, uint8_t buf)
+{
+ int error;
+
+ error = udl_ctrl_msg(sc, UT_WRITE_VENDOR_DEVICE,
+ UDL_CTRL_CMD_WRITE_1, addr, 0x0000, &buf, 1);
+ return (error);
+}
+
+static int
+udl_read_edid(struct udl_softc *sc, uint8_t *buf)
+{
+ uint8_t lbuf[64];
+ uint16_t offset;
+ int error;
+
+ offset = 0;
+
+ error = udl_ctrl_msg(sc, UT_READ_VENDOR_DEVICE,
+ UDL_CTRL_CMD_READ_EDID, 0x00a1, (offset << 8), lbuf, 64);
+ if (error != USB_ERR_NORMAL_COMPLETION)
+ goto fail;
+ bcopy(lbuf + 1, buf + offset, 63);
+ offset += 63;
+
+ error = udl_ctrl_msg(sc, UT_READ_VENDOR_DEVICE,
+ UDL_CTRL_CMD_READ_EDID, 0x00a1, (offset << 8), lbuf, 64);
+ if (error != USB_ERR_NORMAL_COMPLETION)
+ goto fail;
+ bcopy(lbuf + 1, buf + offset, 63);
+ offset += 63;
+
+ error = udl_ctrl_msg(sc, UT_READ_VENDOR_DEVICE,
+ UDL_CTRL_CMD_READ_EDID, 0x00a1, (offset << 8), lbuf, 3);
+ if (error != USB_ERR_NORMAL_COMPLETION)
+ goto fail;
+ bcopy(lbuf + 1, buf + offset, 2);
+fail:
+ return (error);
+}
+
+static uint8_t
+udl_lookup_mode(uint16_t hdisplay, uint16_t vdisplay, uint8_t hz,
+ uint16_t chip, uint32_t clock)
+{
+ uint8_t idx;
+
+ /*
+ * Check first if we have a matching mode with pixelclock
+ */
+ for (idx = 0; idx != UDL_MAX_MODES; idx++) {
+ if ((udl_modes[idx].hdisplay == hdisplay) &&
+ (udl_modes[idx].vdisplay == vdisplay) &&
+ (udl_modes[idx].clock == clock) &&
+ (udl_modes[idx].chip <= chip)) {
+ return (idx);
+ }
+ }
+
+ /*
+ * If not, check for matching mode with update frequency
+ */
+ for (idx = 0; idx != UDL_MAX_MODES; idx++) {
+ if ((udl_modes[idx].hdisplay == hdisplay) &&
+ (udl_modes[idx].vdisplay == vdisplay) &&
+ (udl_modes[idx].hz == hz) &&
+ (udl_modes[idx].chip <= chip)) {
+ return (idx);
+ }
+ }
+ return (idx);
+}
+
+static void
+udl_select_chip(struct udl_softc *sc, struct usb_attach_arg *uaa)
+{
+ const char *pserial;
+
+ pserial = usb_get_serial(uaa->device);
+
+ sc->sc_chip = DL120;
+
+ if ((uaa->info.idVendor == USB_VENDOR_DISPLAYLINK) &&
+ (uaa->info.idProduct == USB_PRODUCT_DISPLAYLINK_WSDVI)) {
+
+ /*
+ * WS Tech DVI is DL120 or DL160. All deviced uses the
+ * same revision (0.04) so iSerialNumber must be used
+ * to determin which chip it is.
+ */
+
+ if (strlen(pserial) > 7) {
+ if (strncmp(pserial, "0198-13", 7) == 0)
+ sc->sc_chip = DL160;
+ }
+ DPRINTF("iSerialNumber (%s) used to select chip (%d)\n",
+ pserial, sc->sc_chip);
+ }
+ if ((uaa->info.idVendor == USB_VENDOR_DISPLAYLINK) &&
+ (uaa->info.idProduct == USB_PRODUCT_DISPLAYLINK_SWDVI)) {
+
+ /*
+ * SUNWEIT DVI is DL160, DL125, DL165 or DL195. Major revision
+ * can be used to differ between DL1x0 and DL1x5. Minor to
+ * differ between DL1x5. iSerialNumber seems not to be uniqe.
+ */
+
+ sc->sc_chip = DL160;
+
+ if (uaa->info.bcdDevice >= 0x100) {
+ sc->sc_chip = DL165;
+ if (uaa->info.bcdDevice == 0x104)
+ sc->sc_chip = DL195;
+ if (uaa->info.bcdDevice == 0x108)
+ sc->sc_chip = DL125;
+ }
+ DPRINTF("bcdDevice (%02x) used to select chip (%d)\n",
+ uaa->info.bcdDevice, sc->sc_chip);
+ }
+}
+
+static int
+udl_set_enc_key(struct udl_softc *sc, uint8_t *buf, uint8_t len)
+{
+ int error;
+
+ error = udl_ctrl_msg(sc, UT_WRITE_VENDOR_DEVICE,
+ UDL_CTRL_CMD_SET_KEY, 0x0000, 0x0000, buf, len);
+ return (error);
+}
+
+static void
+udl_fbmem_alloc(struct udl_softc *sc)
+{
+ uint32_t size;
+
+ size = udl_get_fb_size(sc);
+ size = round_page(size);
+
+ sc->sc_fb_addr = malloc(size, M_DEVBUF, M_WAITOK | M_ZERO);
+ sc->sc_fb_copy = malloc(size, M_DEVBUF, M_WAITOK | M_ZERO);
+ sc->sc_fb_size = size;
+}
+
+static void
+udl_cmd_insert_int_1(struct udl_cmd_buf *cb, uint8_t value)
+{
+
+ cb->buf[cb->off] = value;
+ cb->off += 1;
+}
+
+#if 0
+static void
+udl_cmd_insert_int_2(struct udl_cmd_buf *cb, uint16_t value)
+{
+ uint16_t lvalue;
+
+ lvalue = htobe16(value);
+ bcopy(&lvalue, cb->buf + cb->off, 2);
+
+ cb->off += 2;
+}
+
+#endif
+
+static void
+udl_cmd_insert_int_3(struct udl_cmd_buf *cb, uint32_t value)
+{
+ uint32_t lvalue;
+
+#if BYTE_ORDER == BIG_ENDIAN
+ lvalue = htobe32(value) << 8;
+#else
+ lvalue = htobe32(value) >> 8;
+#endif
+ bcopy(&lvalue, cb->buf + cb->off, 3);
+
+ cb->off += 3;
+}
+
+#if 0
+static void
+udl_cmd_insert_int_4(struct udl_cmd_buf *cb, uint32_t value)
+{
+ uint32_t lvalue;
+
+ lvalue = htobe32(value);
+ bcopy(&lvalue, cb->buf + cb->off, 4);
+
+ cb->off += 4;
+}
+
+#endif
+
+static void
+udl_cmd_insert_buf_le16(struct udl_cmd_buf *cb, const uint8_t *buf, uint32_t len)
+{
+ uint32_t x;
+
+ for (x = 0; x != len; x += 2) {
+ /* byte swap from little endian to big endian */
+ cb->buf[cb->off + x + 0] = buf[x + 1];
+ cb->buf[cb->off + x + 1] = buf[x + 0];
+ }
+ cb->off += len;
+}
+
+static void
+udl_cmd_write_reg_1(struct udl_cmd_buf *cb, uint8_t reg, uint8_t val)
+{
+
+ udl_cmd_insert_int_1(cb, UDL_BULK_SOC);
+ udl_cmd_insert_int_1(cb, UDL_BULK_CMD_REG_WRITE_1);
+ udl_cmd_insert_int_1(cb, reg);
+ udl_cmd_insert_int_1(cb, val);
+}
+
+static void
+udl_cmd_write_reg_3(struct udl_cmd_buf *cb, uint8_t reg, uint32_t val)
+{
+
+ udl_cmd_write_reg_1(cb, reg + 0, (val >> 16) & 0xff);
+ udl_cmd_write_reg_1(cb, reg + 1, (val >> 8) & 0xff);
+ udl_cmd_write_reg_1(cb, reg + 2, (val >> 0) & 0xff);
+}
+
+static int
+udl_init_chip(struct udl_softc *sc)
+{
+ uint32_t ui32;
+ uint8_t ui8;
+ int error;
+
+ error = udl_poll(sc, &ui32);
+ if (error != USB_ERR_NORMAL_COMPLETION)
+ return (error);
+ DPRINTF("poll=0x%08x\n", ui32);
+
+ /* Some products may use later chip too */
+ switch (ui32 & 0xff) {
+ case 0xf1: /* DL1x5 */
+ switch (sc->sc_chip) {
+ case DL120:
+ sc->sc_chip = DL125;
+ break;
+ case DL160:
+ sc->sc_chip = DL165;
+ break;
+ }
+ break;
+ }
+ DPRINTF("chip 0x%04x\n", sc->sc_chip);
+
+ error = udl_read_1(sc, 0xc484, &ui8);
+ if (error != USB_ERR_NORMAL_COMPLETION)
+ return (error);
+ DPRINTF("read 0x%02x from 0xc484\n", ui8);
+
+ error = udl_write_1(sc, 0xc41f, 0x01);
+ if (error != USB_ERR_NORMAL_COMPLETION)
+ return (error);
+ DPRINTF("write 0x01 to 0xc41f\n");
+
+ error = udl_read_edid(sc, sc->sc_edid);
+ if (error != USB_ERR_NORMAL_COMPLETION)
+ return (error);
+ DPRINTF("read EDID\n");
+
+ error = udl_set_enc_key(sc, __DECONST(void *, udl_null_key_1),
+ sizeof(udl_null_key_1));
+ if (error != USB_ERR_NORMAL_COMPLETION)
+ return (error);
+ DPRINTF("set encryption key\n");
+
+ error = udl_write_1(sc, 0xc40b, 0x00);
+ if (error != USB_ERR_NORMAL_COMPLETION)
+ return (error);
+ DPRINTF("write 0x00 to 0xc40b\n");
+
+ return (USB_ERR_NORMAL_COMPLETION);
+}
+
+static void
+udl_init_fb_offsets(struct udl_cmd_buf *cb, uint32_t start16, uint32_t stride16,
+ uint32_t start8, uint32_t stride8)
+{
+ udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0x00);
+ udl_cmd_write_reg_3(cb, UDL_REG_ADDR_START16, start16);
+ udl_cmd_write_reg_3(cb, UDL_REG_ADDR_STRIDE16, stride16);
+ udl_cmd_write_reg_3(cb, UDL_REG_ADDR_START8, start8);
+ udl_cmd_write_reg_3(cb, UDL_REG_ADDR_STRIDE8, stride8);
+ udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0xff);
+}
+
+static int
+udl_init_resolution(struct udl_softc *sc)
+{
+ const uint32_t max = udl_get_fb_size(sc);
+ const uint8_t *buf = udl_modes[sc->sc_cur_mode].mode;
+ struct udl_cmd_buf *cb;
+ uint32_t delta;
+ uint32_t i;
+ int error;
+
+ /* get new buffer */
+ cb = udl_cmd_buf_alloc(sc, M_WAITOK);
+ if (cb == NULL)
+ return (EAGAIN);
+
+ /* write resolution values and set video memory offsets */
+ udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0x00);
+ for (i = 0; i < UDL_MODE_SIZE; i++)
+ udl_cmd_write_reg_1(cb, i, buf[i]);
+ udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0xff);
+
+ udl_init_fb_offsets(cb, 0x000000, 0x000a00, 0x555555, 0x000500);
+ udl_cmd_buf_send(sc, cb);
+
+ /* fill screen with black color */
+ for (i = 0; i < max; i += delta) {
+ static const uint8_t udl_black[UDL_CMD_MAX_PIXEL_COUNT * 2] __aligned(4);
+
+ delta = max - i;
+ if (delta > UDL_CMD_MAX_PIXEL_COUNT * 2)
+ delta = UDL_CMD_MAX_PIXEL_COUNT * 2;
+ if (i == 0)
+ error = udl_cmd_write_buf_le16(sc, udl_black, i, delta / 2, M_WAITOK);
+ else
+ error = udl_cmd_buf_copy_le16(sc, 0, i, delta / 2, M_WAITOK);
+ if (error)
+ return (error);
+ }
+
+ /* get new buffer */
+ cb = udl_cmd_buf_alloc(sc, M_WAITOK);
+ if (cb == NULL)
+ return (EAGAIN);
+
+ /* show framebuffer content */
+ udl_cmd_write_reg_1(cb, UDL_REG_SCREEN, UDL_REG_SCREEN_ON);
+ udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0xff);
+ udl_cmd_buf_send(sc, cb);
+ return (0);
+}
+
+static void
+udl_select_mode(struct udl_softc *sc)
+{
+ struct udl_mode mode;
+ int index = UDL_MAX_MODES;
+ int i;
+
+ /* try to get the preferred mode from EDID */
+ edid_parse(sc->sc_edid, &sc->sc_edid_info);
+#ifdef USB_DEBUG
+ edid_print(&sc->sc_edid_info);
+#endif
+ if (sc->sc_edid_info.edid_preferred_mode != NULL) {
+ mode.hz =
+ (sc->sc_edid_info.edid_preferred_mode->dot_clock * 1000) /
+ (sc->sc_edid_info.edid_preferred_mode->htotal *
+ sc->sc_edid_info.edid_preferred_mode->vtotal);
+ mode.clock =
+ sc->sc_edid_info.edid_preferred_mode->dot_clock / 10;
+ mode.hdisplay =
+ sc->sc_edid_info.edid_preferred_mode->hdisplay;
+ mode.vdisplay =
+ sc->sc_edid_info.edid_preferred_mode->vdisplay;
+ index = udl_lookup_mode(mode.hdisplay, mode.vdisplay, mode.hz,
+ sc->sc_chip, mode.clock);
+ sc->sc_cur_mode = index;
+ } else {
+ DPRINTF("no preferred mode found!\n");
+ }
+
+ if (index == UDL_MAX_MODES) {
+ DPRINTF("no mode line found for %dx%d @ %dHz!\n",
+ mode.hdisplay, mode.vdisplay, mode.hz);
+
+ i = 0;
+ while (i < sc->sc_edid_info.edid_nmodes) {
+ mode.hz =
+ (sc->sc_edid_info.edid_modes[i].dot_clock * 1000) /
+ (sc->sc_edid_info.edid_modes[i].htotal *
+ sc->sc_edid_info.edid_modes[i].vtotal);
+ mode.clock =
+ sc->sc_edid_info.edid_modes[i].dot_clock / 10;
+ mode.hdisplay =
+ sc->sc_edid_info.edid_modes[i].hdisplay;
+ mode.vdisplay =
+ sc->sc_edid_info.edid_modes[i].vdisplay;
+ index = udl_lookup_mode(mode.hdisplay, mode.vdisplay,
+ mode.hz, sc->sc_chip, mode.clock);
+ if (index < UDL_MAX_MODES)
+ if ((sc->sc_cur_mode == UDL_MAX_MODES) ||
+ (index > sc->sc_cur_mode))
+ sc->sc_cur_mode = index;
+ i++;
+ }
+ }
+ /*
+ * If no mode found use default.
+ */
+ if (sc->sc_cur_mode == UDL_MAX_MODES)
+ sc->sc_cur_mode = udl_lookup_mode(800, 600, 60, sc->sc_chip, 0);
+}
+
+static int
+udl_cmd_write_buf_le16(struct udl_softc *sc, const uint8_t *buf, uint32_t off,
+ uint8_t pixels, int flags)
+{
+ struct udl_cmd_buf *cb;
+
+ cb = udl_cmd_buf_alloc(sc, flags);
+ if (cb == NULL)
+ return (EAGAIN);
+
+ udl_cmd_insert_int_1(cb, UDL_BULK_SOC);
+ udl_cmd_insert_int_1(cb, UDL_BULK_CMD_FB_WRITE | UDL_BULK_CMD_FB_WORD);
+ udl_cmd_insert_int_3(cb, off);
+ udl_cmd_insert_int_1(cb, pixels);
+ udl_cmd_insert_buf_le16(cb, buf, 2 * pixels);
+ udl_cmd_buf_send(sc, cb);
+
+ return (0);
+}
+
+static int
+udl_cmd_buf_copy_le16(struct udl_softc *sc, uint32_t src, uint32_t dst,
+ uint8_t pixels, int flags)
+{
+ struct udl_cmd_buf *cb;
+
+ cb = udl_cmd_buf_alloc(sc, flags);
+ if (cb == NULL)
+ return (EAGAIN);
+
+ udl_cmd_insert_int_1(cb, UDL_BULK_SOC);
+ udl_cmd_insert_int_1(cb, UDL_BULK_CMD_FB_COPY | UDL_BULK_CMD_FB_WORD);
+ udl_cmd_insert_int_3(cb, 2 * dst);
+ udl_cmd_insert_int_1(cb, pixels);
+ udl_cmd_insert_int_3(cb, 2 * src);
+ udl_cmd_buf_send(sc, cb);
+
+ return (0);
+}
diff --git a/sys/dev/usb/video/udl.h b/sys/dev/usb/video/udl.h
new file mode 100644
index 0000000000000..d644314777541
--- /dev/null
+++ b/sys/dev/usb/video/udl.h
@@ -0,0 +1,311 @@
+/* $OpenBSD: udl.h,v 1.21 2013/04/15 09:23:02 mglocker Exp $ */
+/* $FreeBSD$ */
+
+/*
+ * Copyright (c) 2009 Marcus Glocker <mglocker@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _UDL_H_
+#define _UDL_H_
+
+#include <sys/types.h>
+#include <sys/queue.h>
+
+/*
+ * BULK command transfer structure.
+ */
+#define UDL_CMD_MAX_FRAMES 64 /* units */
+#define UDL_CMD_MAX_DATA_SIZE 512 /* bytes */
+#define UDL_CMD_MAX_HEAD_SIZE 16 /* bytes */
+#define UDL_CMD_MAX_PIXEL_COUNT ((UDL_CMD_MAX_DATA_SIZE - UDL_CMD_MAX_HEAD_SIZE) / 2)
+#define UDL_CMD_MAX_BUFFERS 2048 /* units */
+#define UDL_FONT_HEIGHT 16 /* pixels */
+#define UDL_MAX_MODES 25 /* units */
+
+struct udl_cmd_buf {
+ TAILQ_ENTRY(udl_cmd_buf) entry;
+ uint32_t off;
+ uint8_t buf[UDL_CMD_MAX_DATA_SIZE] __aligned(4);
+};
+
+TAILQ_HEAD(udl_cmd_head, udl_cmd_buf);
+
+enum {
+ UDL_BULK_WRITE_0,
+ UDL_BULK_WRITE_1,
+ UDL_N_TRANSFER,
+};
+
+/*
+ * Our per device structure.
+ */
+struct udl_softc {
+ struct mtx sc_mtx;
+ struct cv sc_cv;
+ struct callout sc_callout;
+ struct usb_xfer *sc_xfer[UDL_N_TRANSFER];
+ struct usb_device *sc_udev;
+ device_t sc_fbdev;
+ struct fb_info sc_fb_info;
+ uint8_t sc_edid[128];
+ struct edid_info sc_edid_info;
+ struct udl_cmd_head sc_xfer_head[2];
+ struct udl_cmd_head sc_cmd_buf_free;
+ struct udl_cmd_head sc_cmd_buf_pending;
+ struct udl_cmd_buf sc_cmd_buf_temp[UDL_CMD_MAX_BUFFERS];
+ uint32_t sc_sync_off;
+ uint32_t sc_fb_size;
+ uint8_t *sc_fb_addr;
+ uint8_t *sc_fb_copy;
+ int sc_def_chip; /* default chip version */
+ int sc_chip;
+#define DLALL 0x0000
+#define DL125 0x0000 /* max 1280x1024, 1440x900 */
+#define DL120 0x0001 /* max 1280x1024, 1440x1050 */
+#define DL160 0x0002 /* max 1600x1200, 1680x1050 */
+#define DL165 0x0003 /* max 1600x1200, 1920x1080 */
+#define DL195 0x0004 /* max 1920x1200, 2048x1152 */
+#define DLMAX 0x0004
+#define DLUNK 0x00ff /* unknown */
+ int sc_def_mode; /* default mode */
+ int sc_cur_mode;
+ uint8_t sc_power_save; /* set if power save is enabled */
+ uint8_t sc_gone;
+};
+
+#define UDL_LOCK(sc) mtx_lock(&(sc)->sc_mtx)
+#define UDL_UNLOCK(sc) mtx_unlock(&(sc)->sc_mtx)
+
+/*
+ * Chip commands.
+ */
+#define UDL_CTRL_CMD_READ_EDID 0x02
+#define UDL_CTRL_CMD_WRITE_1 0x03
+#define UDL_CTRL_CMD_READ_1 0x04
+#define UDL_CTRL_CMD_POLL 0x06
+#define UDL_CTRL_CMD_SET_KEY 0x12
+
+#define UDL_BULK_SOC 0xaf /* start of command token */
+
+#define UDL_BULK_CMD_REG_WRITE_1 0x20 /* write 1 byte to register */
+#define UDL_BULK_CMD_EOC 0xa0 /* end of command stack */
+#define UDL_BULK_CMD_DECOMP 0xe0 /* send decompression table */
+
+#define UDL_BULK_CMD_FB_BASE 0x60
+#define UDL_BULK_CMD_FB_WORD 0x08
+#define UDL_BULK_CMD_FB_COMP 0x10
+#define UDL_BULK_CMD_FB_WRITE (UDL_BULK_CMD_FB_BASE | 0x00)
+#define UDL_BULK_CMD_FB_COPY (UDL_BULK_CMD_FB_BASE | 0x02)
+
+/*
+ * Chip registers.
+ */
+#define UDL_REG_ADDR_START16 0x20
+#define UDL_REG_ADDR_STRIDE16 0x23
+#define UDL_REG_ADDR_START8 0x26
+#define UDL_REG_ADDR_STRIDE8 0x29
+
+#define UDL_REG_SCREEN 0x1f
+#define UDL_REG_SCREEN_ON 0x00
+#define UDL_REG_SCREEN_OFF 0x01
+#define UDL_REG_SYNC 0xff
+
+#define UDL_MODE_SIZE 29
+
+/*
+ * Register values for screen resolution initialization.
+ */
+static const uint8_t udl_reg_vals_640x480_60[UDL_MODE_SIZE] = { /* 25.17 Mhz 59.9 Hz
+ * VESA std */
+ 0x00, 0x99, 0x30, 0x26, 0x94, 0x60, 0xa9, 0xce, 0x60, 0x07, 0xb3, 0x0f,
+ 0x79, 0xff, 0xff, 0x02, 0x80, 0x83, 0xbc, 0xff, 0xfc, 0xff, 0xff, 0x01,
+ 0xe0, 0x01, 0x02, 0xab, 0x13
+};
+static const uint8_t udl_reg_vals_640x480_67[UDL_MODE_SIZE] = { /* 30.25 MHz 66.6 Hz MAC
+ * std */
+ 0x00, 0x1d, 0x33, 0x07, 0xb3, 0x60, 0xa9, 0xce, 0x60, 0xb6, 0xa8, 0xff,
+ 0xff, 0xbf, 0x70, 0x02, 0x80, 0x83, 0xbc, 0xff, 0xff, 0xff, 0xf9, 0x01,
+ 0xe0, 0x01, 0x02, 0xa2, 0x17
+};
+static const uint8_t udl_reg_vals_640x480_72[UDL_MODE_SIZE] = { /* 31.50 Mhz 72.8 Hz
+ * VESA std */
+ 0x00, 0x2b, 0xeb, 0x35, 0xd3, 0x0a, 0x95, 0xe6, 0x0e, 0x0f, 0xb5, 0x15,
+ 0x2a, 0xff, 0xff, 0x02, 0x80, 0xcc, 0x1d, 0xff, 0xf9, 0xff, 0xff, 0x01,
+ 0xe0, 0x01, 0x02, 0x9c, 0x18
+};
+static const uint8_t udl_reg_vals_640x480_75[UDL_MODE_SIZE] = { /* 31.50 Mhz 75.7 Hz
+ * VESA std */
+ 0x00, 0xeb, 0xf7, 0xd3, 0x0f, 0x4f, 0x93, 0xfa, 0x47, 0xb5, 0x58, 0xff,
+ 0xff, 0xbf, 0x70, 0x02, 0x80, 0xf4, 0x8f, 0xff, 0xff, 0xff, 0xf9, 0x01,
+ 0xe0, 0x01, 0x02, 0x9c, 0x18
+};
+static const uint8_t udl_reg_vals_800x480_61[UDL_MODE_SIZE] = { /* 33.00 MHz 61.9 Hz */
+ 0x00, 0x20, 0x3c, 0x7a, 0xc9, 0xf2, 0x6c, 0x48, 0xf9, 0x70, 0x53, 0xff,
+ 0xff, 0x21, 0x27, 0x03, 0x20, 0x91, 0xf3, 0xff, 0xff, 0xff, 0xf9, 0x01,
+ 0xe0, 0x01, 0x02, 0xc8, 0x19
+};
+static const uint8_t udl_reg_vals_800x600_56[UDL_MODE_SIZE] = { /* 36.00 MHz 56.2 Hz
+ * VESA std */
+ 0x00, 0x65, 0x35, 0x48, 0xf4, 0xf2, 0x6c, 0x19, 0x18, 0xc9, 0x4b, 0xff,
+ 0xff, 0x70, 0x35, 0x03, 0x20, 0x32, 0x31, 0xff, 0xff, 0xff, 0xfc, 0x02,
+ 0x58, 0x01, 0x02, 0x20, 0x1c
+};
+static const uint8_t udl_reg_vals_800x600_60[UDL_MODE_SIZE] = { /* 40.00 MHz 60.3 Hz
+ * VESA std */
+ 0x00, 0x20, 0x3c, 0x7a, 0xc9, 0x93, 0x60, 0xc8, 0xc7, 0x70, 0x53, 0xff,
+ 0xff, 0x21, 0x27, 0x03, 0x20, 0x91, 0x8f, 0xff, 0xff, 0xff, 0xf2, 0x02,
+ 0x58, 0x01, 0x02, 0x40, 0x1f
+};
+static const uint8_t udl_reg_vals_800x600_72[UDL_MODE_SIZE] = { /* 50.00 MHz 72.1 Hz
+ * VESA std */
+ 0x00, 0xeb, 0xf7, 0xd1, 0x90, 0x4d, 0x82, 0x23, 0x1f, 0x39, 0xcf, 0xff,
+ 0xff, 0x43, 0x21, 0x03, 0x20, 0x62, 0xc5, 0xff, 0xff, 0xff, 0xca, 0x02,
+ 0x58, 0x01, 0x02, 0x10, 0x27
+};
+static const uint8_t udl_reg_vals_800x600_74[UDL_MODE_SIZE] = { /* 50.00 MHz 74.4 Hz */
+ 0x00, 0xb3, 0x76, 0x39, 0xcf, 0x60, 0xa9, 0xc7, 0xf4, 0x70, 0x53, 0xff,
+ 0xff, 0x35, 0x33, 0x03, 0x20, 0x8f, 0xe9, 0xff, 0xff, 0xff, 0xf9, 0x02,
+ 0x58, 0x01, 0x02, 0x10, 0x27
+};
+static const uint8_t udl_reg_vals_800x600_75[UDL_MODE_SIZE] = { /* 49.50 MHz 75.0 Hz
+ * VESA std */
+ 0x00, 0xb3, 0x76, 0x39, 0xcf, 0xf2, 0x6c, 0x19, 0x18, 0x70, 0x53, 0xff,
+ 0xff, 0x35, 0x33, 0x03, 0x20, 0x32, 0x31, 0xff, 0xff, 0xff, 0xf9, 0x02,
+ 0x58, 0x01, 0x02, 0xac, 0x26
+};
+static const uint8_t udl_reg_vals_1024x768_60[UDL_MODE_SIZE] = { /* 65.00 MHz 60.0 Hz
+ * VESA std */
+ 0x00, 0x36, 0x18, 0xd5, 0x10, 0x60, 0xa9, 0x7b, 0x33, 0xa1, 0x2b, 0x27,
+ 0x32, 0xff, 0xff, 0x04, 0x00, 0xd9, 0x9a, 0xff, 0xca, 0xff, 0xff, 0x03,
+ 0x00, 0x04, 0x03, 0xc8, 0x32
+};
+static const uint8_t udl_reg_vals_1024x768_70[UDL_MODE_SIZE] = { /* 75.00 MHz 70.0 Hz
+ * VESA std */
+ 0x00, 0xb4, 0xed, 0x4c, 0x5e, 0x60, 0xa9, 0x7b, 0x33, 0x10, 0x4d, 0xff,
+ 0xff, 0x27, 0x32, 0x04, 0x00, 0xd9, 0x9a, 0xff, 0xff, 0xff, 0xca, 0x03,
+ 0x00, 0x04, 0x02, 0x98, 0x3a
+};
+static const uint8_t udl_reg_vals_1024x768_75[UDL_MODE_SIZE] = { /* 78.75 MHz 75.0 Hz
+ * VESA std */
+ 0x00, 0xec, 0xb4, 0xa0, 0x4c, 0x36, 0x0a, 0x07, 0xb3, 0x5e, 0xd5, 0xff,
+ 0xff, 0x0f, 0x79, 0x04, 0x00, 0x0f, 0x66, 0xff, 0xff, 0xff, 0xf9, 0x03,
+ 0x00, 0x04, 0x02, 0x86, 0x3d
+};
+static const uint8_t udl_reg_vals_1280x800_60[UDL_MODE_SIZE] = { /* 83.46 MHz 59.9 MHz */
+ 0x00, 0xb2, 0x19, 0x34, 0xdf, 0x93, 0x60, 0x30, 0xfb, 0x9f, 0xca, 0xff,
+ 0xff, 0x27, 0x32, 0x05, 0x00, 0x61, 0xf6, 0xff, 0xff, 0xff, 0xf9, 0x03,
+ 0x20, 0x04, 0x02, 0x34, 0x41
+};
+static const uint8_t udl_reg_vals_1280x960_60[UDL_MODE_SIZE] = { /* 108.00 MHz 60.0 Hz
+ * VESA std */
+ 0x00, 0xa6, 0x03, 0x5c, 0x7e, 0x0a, 0x95, 0x48, 0xf4, 0x61, 0xbd, 0xff,
+ 0xff, 0x94, 0x43, 0x05, 0x00, 0x91, 0xe8, 0xff, 0xff, 0xff, 0xf9, 0x03,
+ 0xc0, 0x04, 0x02, 0x60, 0x54
+};
+static const uint8_t udl_reg_vals_1280x1024_60[UDL_MODE_SIZE] = { /* 108.00 MHz 60.0 Hz
+ * VESA std */
+ 0x00, 0x98, 0xf8, 0x0d, 0x57, 0x2a, 0x55, 0x4d, 0x54, 0xca, 0x0d, 0xff,
+ 0xff, 0x94, 0x43, 0x05, 0x00, 0x9a, 0xa8, 0xff, 0xff, 0xff, 0xf9, 0x04,
+ 0x00, 0x04, 0x02, 0x60, 0x54
+};
+static const uint8_t udl_reg_vals_1280x1024_75[UDL_MODE_SIZE] = { /* 135.00 MHz 75.0 Hz
+ * VESA std */
+ 0x00, 0xce, 0x12, 0x3f, 0x9f, 0x2a, 0x55, 0x4d, 0x54, 0xca, 0x0d, 0xff,
+ 0xff, 0x32, 0x60, 0x05, 0x00, 0x9a, 0xa8, 0xff, 0xff, 0xff, 0xf9, 0x04,
+ 0x00, 0x04, 0x02, 0x78, 0x69
+};
+static const uint8_t udl_reg_vals_1366x768_60[UDL_MODE_SIZE] = { /* 90 MHz 60.0 Hz */
+ 0x01, 0x19, 0x1e, 0x1f, 0xb0, 0x93, 0x60, 0x40, 0x7b, 0x36, 0xe8, 0x27,
+ 0x32, 0xff, 0xff, 0x05, 0x56, 0x03, 0xd9, 0xff, 0xff, 0xfc, 0xa7, 0x03,
+ 0x00, 0x04, 0x02, 0x9a, 0x42
+};
+static const uint8_t udl_reg_vals_1440x900_60[UDL_MODE_SIZE] = { /* 106.47 MHz 59.9 Hz */
+ 0x00, 0x24, 0xce, 0xe7, 0x72, 0x36, 0x0a, 0x86, 0xca, 0x1c, 0x10, 0xff,
+ 0xff, 0x60, 0x3a, 0x05, 0xa0, 0x0d, 0x94, 0xff, 0xff, 0xff, 0xf9, 0x03,
+ 0x84, 0x04, 0x02, 0x2e, 0x53
+};
+static const uint8_t udl_reg_vals_1440x900_59[UDL_MODE_SIZE] = { /* 106.50 MHz 59.8 Hz */
+ 0x00, 0x24, 0xce, 0xe7, 0x72, 0xd8, 0x2a, 0x1b, 0x28, 0x1c, 0x10, 0xff,
+ 0xff, 0x60, 0x3a, 0x05, 0xa0, 0x36, 0x50, 0xff, 0xff, 0xff, 0xf9, 0x03,
+ 0x84, 0x04, 0x02, 0x34, 0x53
+};
+static const uint8_t udl_reg_vals_1440x900_75[UDL_MODE_SIZE] = { /* 136.49 MHz 75.0 Hz */
+ 0x00, 0x73, 0xa6, 0x14, 0xea, 0x0a, 0x95, 0xca, 0x10, 0x7f, 0x46, 0xff,
+ 0xff, 0x60, 0x3a, 0x05, 0xa0, 0x94, 0x20, 0xff, 0xff, 0xff, 0xf9, 0x03,
+ 0x84, 0x04, 0x02, 0xa2, 0x6a
+};
+static const uint8_t udl_reg_vals_1680x1050_60[UDL_MODE_SIZE] = { /* 147.14 MHz 60.0 Hz */
+ 0x00, 0x53, 0x43, 0xa6, 0x71, 0xc1, 0x52, 0xd9, 0x29, 0x69, 0x9f, 0xff,
+ 0xff, 0xd7, 0xee, 0x06, 0x90, 0xb2, 0x53, 0xff, 0xff, 0xff, 0xf9, 0x04,
+ 0x1a, 0x04, 0x02, 0xf4, 0x72
+};
+static const uint8_t udl_reg_vals_1600x1200_60[UDL_MODE_SIZE] = { /* 162.00 MHz 60.0 Hz
+ * VESA std */
+ 0x00, 0xcf, 0xa4, 0x3c, 0x4e, 0x55, 0x73, 0x71, 0x2b, 0x71, 0x52, 0xff,
+ 0xff, 0xee, 0xca, 0x06, 0x40, 0xe2, 0x57, 0xff, 0xff, 0xff, 0xf9, 0x04,
+ 0xb0, 0x04, 0x02, 0x90, 0x7e
+};
+static const uint8_t udl_reg_vals_1920x1080_60[UDL_MODE_SIZE] = { /* 138.50 MHz 59.9 Hz */
+ 0x00, 0x73, 0xa6, 0x28, 0xb3, 0x54, 0xaa, 0x41, 0x5d, 0x0d, 0x9f, 0x32,
+ 0x60, 0xff, 0xff, 0x07, 0x80, 0x0a, 0xea, 0xff, 0xf9, 0xff, 0xff, 0x04,
+ 0x38, 0x04, 0x02, 0xe0, 0x7c
+};
+
+struct udl_mode {
+ uint16_t hdisplay;
+ uint16_t vdisplay;
+ uint8_t hz;
+ uint16_t chip;
+ uint32_t clock;
+ const uint8_t *mode;
+};
+
+static const struct udl_mode udl_modes[UDL_MAX_MODES] = {
+ {640, 480, 60, DLALL, 2520, udl_reg_vals_640x480_60},
+ {640, 480, 67, DLALL, 3025, udl_reg_vals_640x480_67},
+ {640, 480, 72, DLALL, 3150, udl_reg_vals_640x480_72},
+ {640, 480, 75, DLALL, 3150, udl_reg_vals_640x480_75},
+ {800, 480, 59, DLALL, 5000, udl_reg_vals_800x480_61},
+ {800, 480, 61, DLALL, 3300, udl_reg_vals_800x480_61},
+ {800, 600, 56, DLALL, 3600, udl_reg_vals_800x600_56},
+ {800, 600, 60, DLALL, 4000, udl_reg_vals_800x600_60},
+ {800, 600, 72, DLALL, 5000, udl_reg_vals_800x600_72},
+ {800, 600, 74, DLALL, 5000, udl_reg_vals_800x600_74},
+ {800, 600, 75, DLALL, 4950, udl_reg_vals_800x600_75},
+ {1024, 768, 60, DLALL, 6500, udl_reg_vals_1024x768_60},
+ {1024, 768, 70, DLALL, 7500, udl_reg_vals_1024x768_70},
+ {1024, 768, 75, DLALL, 7850, udl_reg_vals_1024x768_75},
+ {1280, 800, 60, DLALL, 8346, udl_reg_vals_1280x800_60},
+ {1280, 960, 60, DLALL, 10800, udl_reg_vals_1280x960_60},
+ {1280, 1024, 60, DLALL, 10800, udl_reg_vals_1280x1024_60},
+ {1280, 1024, 75, DLALL, 13500, udl_reg_vals_1280x1024_75},
+ {1366, 768, 60, DLALL, 9000, udl_reg_vals_1366x768_60},
+ {1440, 900, 59, DL125, 10650, udl_reg_vals_1440x900_59},
+ {1440, 900, 60, DL125, 10647, udl_reg_vals_1440x900_60},
+ {1440, 900, 75, DL125, 13649, udl_reg_vals_1440x900_75},
+ {1680, 1050, 60, DL160, 14714, udl_reg_vals_1680x1050_60},
+ {1600, 1200, 60, DL160, 16200, udl_reg_vals_1600x1200_60},
+ {1920, 1080, 60, DL165, 13850, udl_reg_vals_1920x1080_60}
+};
+
+/*
+ * Encryption.
+ */
+static const uint8_t udl_null_key_1[] = {
+ 0x57, 0xcd, 0xdc, 0xa7, 0x1c, 0x88, 0x5e, 0x15, 0x60, 0xfe, 0xc6, 0x97,
+ 0x16, 0x3d, 0x47, 0xf2
+};
+
+#endif /* _UDL_H_ */
diff --git a/sys/modules/usb/udl/Makefile b/sys/modules/usb/udl/Makefile
new file mode 100644
index 0000000000000..53238838e17da
--- /dev/null
+++ b/sys/modules/usb/udl/Makefile
@@ -0,0 +1,12 @@
+# $FreeBSD$
+
+S= ${.CURDIR}/../../..
+
+.PATH: $S/dev/usb/video
+
+KMOD= udl
+SRCS= opt_bus.h opt_usb.h fb_if.h device_if.h \
+ bus_if.h usb_if.h vnode_if.h usbdevs.h \
+ udl.c
+
+.include <bsd.kmod.mk>
generated by cgit v1.3 (git 2.53.0) at 2026-08-06 09:40:15 +0000