xref: /freebsd/sys/dev/usb/video/udl.c (revision c36e54bb328697af1e6113812caecbd3bac89fe0)
1 /*	$OpenBSD: udl.c,v 1.81 2014/12/09 07:05:06 doug Exp $ */
2 /*	$FreeBSD$ */
3 
4 /*-
5  * Copyright (c) 2015 Hans Petter Selasky <hselasky@freebsd.org>
6  * Copyright (c) 2009 Marcus Glocker <mglocker@openbsd.org>
7  *
8  * Permission to use, copy, modify, and distribute this software for any
9  * purpose with or without fee is hereby granted, provided that the above
10  * copyright notice and this permission notice appear in all copies.
11  *
12  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19  */
20 
21 /*
22  * Driver for the "DisplayLink DL-120 / DL-160" graphic chips based on
23  * the reversed engineered specifications of Florian Echtler
24  * <floe@butterbrot.org>:
25  *
26  * 	http://floe.butterbrot.org/displaylink/doku.php
27  */
28 
29 #include <sys/param.h>
30 #include <sys/bus.h>
31 #include <sys/callout.h>
32 #include <sys/conf.h>
33 #include <sys/kernel.h>
34 #include <sys/lock.h>
35 #include <sys/module.h>
36 #include <sys/mutex.h>
37 #include <sys/condvar.h>
38 #include <sys/sysctl.h>
39 #include <sys/systm.h>
40 #include <sys/consio.h>
41 #include <sys/fbio.h>
42 
43 #include <dev/fb/fbreg.h>
44 #include <dev/syscons/syscons.h>
45 
46 #include <dev/videomode/videomode.h>
47 #include <dev/videomode/edidvar.h>
48 
49 #include <dev/usb/usb.h>
50 #include <dev/usb/usbdi.h>
51 #include <dev/usb/usbdi_util.h>
52 #include "usbdevs.h"
53 
54 #include <dev/usb/video/udl.h>
55 
56 #include "fb_if.h"
57 
58 #undef DPRINTF
59 #undef DPRINTFN
60 #define	USB_DEBUG_VAR udl_debug
61 #include <dev/usb/usb_debug.h>
62 
63 static	SYSCTL_NODE(_hw_usb, OID_AUTO, udl, CTLFLAG_RW, 0, "USB UDL");
64 
65 #ifdef USB_DEBUG
66 static int udl_debug = 0;
67 
68 SYSCTL_INT(_hw_usb_udl, OID_AUTO, debug, CTLFLAG_RWTUN,
69     &udl_debug, 0, "Debug level");
70 #endif
71 
72 #define	UDL_FPS_MAX	60
73 #define	UDL_FPS_MIN	1
74 
75 static int udl_fps = 25;
76 SYSCTL_INT(_hw_usb_udl, OID_AUTO, fps, CTLFLAG_RWTUN,
77     &udl_fps, 0, "Frames Per Second, 1-60");
78 
79 static struct mtx udl_buffer_mtx;
80 static struct udl_buffer_head udl_buffer_head;
81 
82 MALLOC_DEFINE(M_USB_DL, "USB", "USB DisplayLink");
83 
84 /*
85  * Prototypes.
86  */
87 static usb_callback_t udl_bulk_write_callback;
88 
89 static device_probe_t udl_probe;
90 static device_attach_t udl_attach;
91 static device_detach_t udl_detach;
92 static fb_getinfo_t udl_fb_getinfo;
93 static fb_setblankmode_t udl_fb_setblankmode;
94 
95 static void udl_select_chip(struct udl_softc *, struct usb_attach_arg *);
96 static int udl_init_chip(struct udl_softc *);
97 static void udl_select_mode(struct udl_softc *);
98 static int udl_init_resolution(struct udl_softc *);
99 static void udl_fbmem_alloc(struct udl_softc *);
100 static int udl_cmd_write_buf_le16(struct udl_softc *, const uint8_t *, uint32_t, uint8_t, int);
101 static int udl_cmd_buf_copy_le16(struct udl_softc *, uint32_t, uint32_t, uint8_t, int);
102 static void udl_cmd_insert_int_1(struct udl_cmd_buf *, uint8_t);
103 static void udl_cmd_insert_int_3(struct udl_cmd_buf *, uint32_t);
104 static void udl_cmd_insert_buf_le16(struct udl_cmd_buf *, const uint8_t *, uint32_t);
105 static void udl_cmd_write_reg_1(struct udl_cmd_buf *, uint8_t, uint8_t);
106 static void udl_cmd_write_reg_3(struct udl_cmd_buf *, uint8_t, uint32_t);
107 static int udl_power_save(struct udl_softc *, int, int);
108 
109 static const struct usb_config udl_config[UDL_N_TRANSFER] = {
110 	[UDL_BULK_WRITE_0] = {
111 		.type = UE_BULK,
112 		.endpoint = UE_ADDR_ANY,
113 		.direction = UE_DIR_TX,
114 		.flags = {.pipe_bof = 1,.force_short_xfer = 1,.ext_buffer = 1,},
115 		.bufsize = UDL_CMD_MAX_DATA_SIZE * UDL_CMD_MAX_FRAMES,
116 		.callback = &udl_bulk_write_callback,
117 		.frames = UDL_CMD_MAX_FRAMES,
118 		.timeout = 5000,	/* 5 seconds */
119 	},
120 	[UDL_BULK_WRITE_1] = {
121 		.type = UE_BULK,
122 		.endpoint = UE_ADDR_ANY,
123 		.direction = UE_DIR_TX,
124 		.flags = {.pipe_bof = 1,.force_short_xfer = 1,.ext_buffer = 1,},
125 		.bufsize = UDL_CMD_MAX_DATA_SIZE * UDL_CMD_MAX_FRAMES,
126 		.callback = &udl_bulk_write_callback,
127 		.frames = UDL_CMD_MAX_FRAMES,
128 		.timeout = 5000,	/* 5 seconds */
129 	},
130 };
131 
132 /*
133  * Driver glue.
134  */
135 static devclass_t udl_devclass;
136 
137 static device_method_t udl_methods[] = {
138 	DEVMETHOD(device_probe, udl_probe),
139 	DEVMETHOD(device_attach, udl_attach),
140 	DEVMETHOD(device_detach, udl_detach),
141 	DEVMETHOD(fb_getinfo, udl_fb_getinfo),
142 	DEVMETHOD_END
143 };
144 
145 static driver_t udl_driver = {
146 	.name = "udl",
147 	.methods = udl_methods,
148 	.size = sizeof(struct udl_softc),
149 };
150 
151 DRIVER_MODULE(udl, uhub, udl_driver, udl_devclass, NULL, NULL);
152 MODULE_DEPEND(udl, usb, 1, 1, 1);
153 MODULE_DEPEND(udl, fbd, 1, 1, 1);
154 MODULE_DEPEND(udl, videomode, 1, 1, 1);
155 MODULE_VERSION(udl, 1);
156 
157 /*
158  * Matching devices.
159  */
160 static const STRUCT_USB_HOST_ID udl_devs[] = {
161 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LCD4300U, DL120)},
162 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LCD8000U, DL120)},
163 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_GUC2020, DL160)},
164 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LD220, DL165)},
165 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_VCUD60, DL160)},
166 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_DLDVI, DL160)},
167 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_VGA10, DL120)},
168 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_WSDVI, DLUNK)},
169 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_EC008, DL160)},
170 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_HPDOCK, DL160)},
171 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_NL571, DL160)},
172 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_M01061, DL195)},
173 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_NBDOCK, DL165)},
174 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_SWDVI, DLUNK)},
175 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_UM7X0, DL120)},
176 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_CONV, DL160)},
177 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_PLUGABLE, DL160)},
178 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LUM70, DL125)},
179 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_POLARIS2, DLUNK)},
180 	{USB_VPI(USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LT1421, DLUNK)}
181 };
182 
183 static void
184 udl_buffer_init(void *arg)
185 {
186 	mtx_init(&udl_buffer_mtx, "USB", "UDL", MTX_DEF);
187 	TAILQ_INIT(&udl_buffer_head);
188 }
189 SYSINIT(udl_buffer_init, SI_SUB_LOCK, SI_ORDER_FIRST, udl_buffer_init, NULL);
190 
191 CTASSERT(sizeof(struct udl_buffer) < PAGE_SIZE);
192 
193 static void *
194 udl_buffer_alloc(uint32_t size)
195 {
196 	struct udl_buffer *buf;
197 	mtx_lock(&udl_buffer_mtx);
198 	TAILQ_FOREACH(buf, &udl_buffer_head, entry) {
199 		if (buf->size == size) {
200 			TAILQ_REMOVE(&udl_buffer_head, buf, entry);
201 			break;
202 		}
203 	}
204 	mtx_unlock(&udl_buffer_mtx);
205 	if (buf != NULL) {
206 		uint8_t *ptr = ((uint8_t *)buf) - size;
207 		/* wipe and recycle buffer */
208 		memset(ptr, 0, size);
209 		/* return buffer pointer */
210 		return (ptr);
211 	}
212 	/* allocate new buffer */
213 	return (malloc(size + sizeof(*buf), M_USB_DL, M_WAITOK | M_ZERO));
214 }
215 
216 static void
217 udl_buffer_free(void *_buf, uint32_t size)
218 {
219 	struct udl_buffer *buf;
220 
221 	/* check for NULL pointer */
222 	if (_buf == NULL)
223 		return;
224 	/* compute pointer to recycle list */
225 	buf = (struct udl_buffer *)(((uint8_t *)_buf) + size);
226 
227 	/*
228 	 * Memory mapped buffers should never be freed.
229 	 * Put display buffer into a recycle list.
230 	 */
231 	mtx_lock(&udl_buffer_mtx);
232 	buf->size = size;
233 	TAILQ_INSERT_TAIL(&udl_buffer_head, buf, entry);
234 	mtx_unlock(&udl_buffer_mtx);
235 }
236 
237 static uint32_t
238 udl_get_fb_size(struct udl_softc *sc)
239 {
240 	unsigned i = sc->sc_cur_mode;
241 
242 	return ((uint32_t)udl_modes[i].hdisplay *
243 	    (uint32_t)udl_modes[i].vdisplay * 2);
244 }
245 
246 static uint32_t
247 udl_get_fb_width(struct udl_softc *sc)
248 {
249 	unsigned i = sc->sc_cur_mode;
250 
251 	return (udl_modes[i].hdisplay);
252 }
253 
254 static uint32_t
255 udl_get_fb_height(struct udl_softc *sc)
256 {
257 	unsigned i = sc->sc_cur_mode;
258 
259 	return (udl_modes[i].vdisplay);
260 }
261 
262 static uint32_t
263 udl_get_fb_hz(struct udl_softc *sc)
264 {
265 	unsigned i = sc->sc_cur_mode;
266 
267 	return (udl_modes[i].hz);
268 }
269 
270 static void
271 udl_callout(void *arg)
272 {
273 	struct udl_softc *sc = arg;
274 	const uint32_t max = udl_get_fb_size(sc);
275 	int fps;
276 
277 	if (sc->sc_power_save == 0) {
278 		fps = udl_fps;
279 
280 	  	/* figure out number of frames per second */
281 		if (fps < UDL_FPS_MIN)
282 			fps = UDL_FPS_MIN;
283 		else if (fps > UDL_FPS_MAX)
284 			fps = UDL_FPS_MAX;
285 
286 		if (sc->sc_sync_off >= max)
287 			sc->sc_sync_off = 0;
288 		usbd_transfer_start(sc->sc_xfer[UDL_BULK_WRITE_0]);
289 		usbd_transfer_start(sc->sc_xfer[UDL_BULK_WRITE_1]);
290 	} else {
291 		fps = 1;
292 	}
293 	callout_reset(&sc->sc_callout, hz / fps, &udl_callout, sc);
294 }
295 
296 static int
297 udl_probe(device_t dev)
298 {
299 	struct usb_attach_arg *uaa = device_get_ivars(dev);
300 
301 	if (uaa->usb_mode != USB_MODE_HOST)
302 		return (ENXIO);
303 	if (uaa->info.bConfigIndex != 0)
304 		return (ENXIO);
305 	if (uaa->info.bIfaceIndex != 0)
306 		return (ENXIO);
307 
308 	return (usbd_lookup_id_by_uaa(udl_devs, sizeof(udl_devs), uaa));
309 }
310 
311 static int
312 udl_attach(device_t dev)
313 {
314 	struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
315 	struct sysctl_oid *tree = device_get_sysctl_tree(dev);
316 	struct udl_softc *sc = device_get_softc(dev);
317 	struct usb_attach_arg *uaa = device_get_ivars(dev);
318 	int error;
319 	int i;
320 
321 	device_set_usb_desc(dev);
322 
323 	mtx_init(&sc->sc_mtx, "UDL lock", NULL, MTX_DEF);
324 	cv_init(&sc->sc_cv, "UDLCV");
325 	callout_init_mtx(&sc->sc_callout, &sc->sc_mtx, 0);
326 	sc->sc_udev = uaa->device;
327 
328 	error = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex,
329 	    sc->sc_xfer, udl_config, UDL_N_TRANSFER, sc, &sc->sc_mtx);
330 
331 	if (error) {
332 		DPRINTF("usbd_transfer_setup error=%s\n", usbd_errstr(error));
333 		goto detach;
334 	}
335 	usbd_xfer_set_priv(sc->sc_xfer[UDL_BULK_WRITE_0], &sc->sc_xfer_head[0]);
336 	usbd_xfer_set_priv(sc->sc_xfer[UDL_BULK_WRITE_1], &sc->sc_xfer_head[1]);
337 
338 	TAILQ_INIT(&sc->sc_xfer_head[0]);
339 	TAILQ_INIT(&sc->sc_xfer_head[1]);
340 	TAILQ_INIT(&sc->sc_cmd_buf_free);
341 	TAILQ_INIT(&sc->sc_cmd_buf_pending);
342 
343 	sc->sc_def_chip = -1;
344 	sc->sc_chip = USB_GET_DRIVER_INFO(uaa);
345 	sc->sc_def_mode = -1;
346 	sc->sc_cur_mode = UDL_MAX_MODES;
347 
348 	/* Allow chip ID to be overwritten */
349 	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "chipid_force",
350 	    CTLFLAG_RWTUN, &sc->sc_def_chip, 0, "chip ID");
351 
352 	/* Export current chip ID */
353 	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "chipid",
354 	    CTLFLAG_RD, &sc->sc_chip, 0, "chip ID");
355 
356 	if (sc->sc_def_chip > -1 && sc->sc_def_chip <= DLMAX) {
357 		device_printf(dev, "Forcing chip ID to 0x%04x\n", sc->sc_def_chip);
358 		sc->sc_chip = sc->sc_def_chip;
359 	}
360 	/*
361 	 * The product might have more than one chip
362 	 */
363 	if (sc->sc_chip == DLUNK)
364 		udl_select_chip(sc, uaa);
365 
366 	for (i = 0; i != UDL_CMD_MAX_BUFFERS; i++) {
367 		struct udl_cmd_buf *cb = &sc->sc_cmd_buf_temp[i];
368 
369 		TAILQ_INSERT_TAIL(&sc->sc_cmd_buf_free, cb, entry);
370 	}
371 
372 	/*
373 	 * Initialize chip.
374 	 */
375 	error = udl_init_chip(sc);
376 	if (error != USB_ERR_NORMAL_COMPLETION)
377 		goto detach;
378 
379 	/*
380 	 * Select edid mode.
381 	 */
382 	udl_select_mode(sc);
383 
384 	/* Allow default mode to be overwritten */
385 	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "mode_force",
386 	    CTLFLAG_RWTUN, &sc->sc_def_mode, 0, "mode");
387 
388 	/* Export current mode */
389 	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "mode",
390 	    CTLFLAG_RD, &sc->sc_cur_mode, 0, "mode");
391 
392 	i = sc->sc_def_mode;
393 	if (i > -1 && i < UDL_MAX_MODES) {
394 		if (udl_modes[i].chip <= sc->sc_chip) {
395 			device_printf(dev, "Forcing mode to %d\n", i);
396 			sc->sc_cur_mode = i;
397 		}
398 	}
399 	/* Printout current mode */
400 	device_printf(dev, "Mode selected %dx%d @ %dHz\n",
401 	    (int)udl_get_fb_width(sc),
402 	    (int)udl_get_fb_height(sc),
403 	    (int)udl_get_fb_hz(sc));
404 
405 	udl_init_resolution(sc);
406 
407 	/* Allocate frame buffer */
408 	udl_fbmem_alloc(sc);
409 
410 	UDL_LOCK(sc);
411 	udl_callout(sc);
412 	UDL_UNLOCK(sc);
413 
414 	sc->sc_fb_info.fb_name = device_get_nameunit(dev);
415 	sc->sc_fb_info.fb_size = sc->sc_fb_size;
416 	sc->sc_fb_info.fb_bpp = 16;
417 	sc->sc_fb_info.fb_depth = 16;
418 	sc->sc_fb_info.fb_width = udl_get_fb_width(sc);
419 	sc->sc_fb_info.fb_height = udl_get_fb_height(sc);
420 	sc->sc_fb_info.fb_stride = sc->sc_fb_info.fb_width * 2;
421 	sc->sc_fb_info.fb_pbase = 0;
422 	sc->sc_fb_info.fb_vbase = (uintptr_t)sc->sc_fb_addr;
423 	sc->sc_fb_info.fb_priv = sc;
424 	sc->sc_fb_info.setblankmode = &udl_fb_setblankmode;
425 
426 	sc->sc_fbdev = device_add_child(dev, "fbd", -1);
427 	if (sc->sc_fbdev == NULL)
428 		goto detach;
429 	if (device_probe_and_attach(sc->sc_fbdev) != 0)
430 		goto detach;
431 
432 	return (0);
433 
434 detach:
435 	udl_detach(dev);
436 
437 	return (ENXIO);
438 }
439 
440 static int
441 udl_detach(device_t dev)
442 {
443 	struct udl_softc *sc = device_get_softc(dev);
444 
445 	if (sc->sc_fbdev != NULL) {
446 		device_t bdev;
447 
448 		bdev = sc->sc_fbdev;
449 		sc->sc_fbdev = NULL;
450 		device_detach(bdev);
451 		device_delete_child(dev, bdev);
452 	}
453 	UDL_LOCK(sc);
454 	sc->sc_gone = 1;
455 	callout_stop(&sc->sc_callout);
456 	UDL_UNLOCK(sc);
457 
458 	usbd_transfer_unsetup(sc->sc_xfer, UDL_N_TRANSFER);
459 
460 	callout_drain(&sc->sc_callout);
461 
462 	mtx_destroy(&sc->sc_mtx);
463 	cv_destroy(&sc->sc_cv);
464 
465 	/* put main framebuffer into a recycle list, if any */
466 	udl_buffer_free(sc->sc_fb_addr, sc->sc_fb_size);
467 
468 	/* free shadow framebuffer memory, if any */
469 	free(sc->sc_fb_copy, M_USB_DL);
470 
471 	return (0);
472 }
473 
474 static struct fb_info *
475 udl_fb_getinfo(device_t dev)
476 {
477 	struct udl_softc *sc = device_get_softc(dev);
478 
479 	return (&sc->sc_fb_info);
480 }
481 
482 static int
483 udl_fb_setblankmode(void *arg, int mode)
484 {
485 	struct udl_softc *sc = arg;
486 
487 	switch (mode) {
488 	case V_DISPLAY_ON:
489 		udl_power_save(sc, 1, M_WAITOK);
490 		break;
491 	case V_DISPLAY_BLANK:
492 		udl_power_save(sc, 1, M_WAITOK);
493 		if (sc->sc_fb_addr != 0) {
494 			const uint32_t max = udl_get_fb_size(sc);
495 
496 			memset((void *)sc->sc_fb_addr, 0, max);
497 		}
498 		break;
499 	case V_DISPLAY_STAND_BY:
500 	case V_DISPLAY_SUSPEND:
501 		udl_power_save(sc, 0, M_WAITOK);
502 		break;
503 	}
504 	return (0);
505 }
506 
507 static struct udl_cmd_buf *
508 udl_cmd_buf_alloc_locked(struct udl_softc *sc, int flags)
509 {
510 	struct udl_cmd_buf *cb;
511 
512 	while ((cb = TAILQ_FIRST(&sc->sc_cmd_buf_free)) == NULL) {
513 		if (flags != M_WAITOK)
514 			break;
515 		cv_wait(&sc->sc_cv, &sc->sc_mtx);
516 	}
517 	if (cb != NULL) {
518 		TAILQ_REMOVE(&sc->sc_cmd_buf_free, cb, entry);
519 		cb->off = 0;
520 	}
521 	return (cb);
522 }
523 
524 static struct udl_cmd_buf *
525 udl_cmd_buf_alloc(struct udl_softc *sc, int flags)
526 {
527 	struct udl_cmd_buf *cb;
528 
529 	UDL_LOCK(sc);
530 	cb = udl_cmd_buf_alloc_locked(sc, flags);
531 	UDL_UNLOCK(sc);
532 	return (cb);
533 }
534 
535 static void
536 udl_cmd_buf_send(struct udl_softc *sc, struct udl_cmd_buf *cb)
537 {
538 	UDL_LOCK(sc);
539 	if (sc->sc_gone) {
540 		TAILQ_INSERT_TAIL(&sc->sc_cmd_buf_free, cb, entry);
541 	} else {
542 		/* mark end of command stack */
543 		udl_cmd_insert_int_1(cb, UDL_BULK_SOC);
544 		udl_cmd_insert_int_1(cb, UDL_BULK_CMD_EOC);
545 
546 		TAILQ_INSERT_TAIL(&sc->sc_cmd_buf_pending, cb, entry);
547 		usbd_transfer_start(sc->sc_xfer[UDL_BULK_WRITE_0]);
548 		usbd_transfer_start(sc->sc_xfer[UDL_BULK_WRITE_1]);
549 	}
550 	UDL_UNLOCK(sc);
551 }
552 
553 static struct udl_cmd_buf *
554 udl_fb_synchronize_locked(struct udl_softc *sc)
555 {
556 	const uint32_t max = udl_get_fb_size(sc);
557 
558 	/* check if framebuffer is not ready */
559 	if (sc->sc_fb_addr == NULL ||
560 	    sc->sc_fb_copy == NULL)
561 		return (NULL);
562 
563 	while (sc->sc_sync_off < max) {
564 		uint32_t delta = max - sc->sc_sync_off;
565 
566 		if (delta > UDL_CMD_MAX_PIXEL_COUNT * 2)
567 			delta = UDL_CMD_MAX_PIXEL_COUNT * 2;
568 		if (bcmp(sc->sc_fb_addr + sc->sc_sync_off, sc->sc_fb_copy + sc->sc_sync_off, delta) != 0) {
569 			struct udl_cmd_buf *cb;
570 
571 			cb = udl_cmd_buf_alloc_locked(sc, M_NOWAIT);
572 			if (cb == NULL)
573 				goto done;
574 			memcpy(sc->sc_fb_copy + sc->sc_sync_off,
575 			    sc->sc_fb_addr + sc->sc_sync_off, delta);
576 			udl_cmd_insert_int_1(cb, UDL_BULK_SOC);
577 			udl_cmd_insert_int_1(cb, UDL_BULK_CMD_FB_WRITE | UDL_BULK_CMD_FB_WORD);
578 			udl_cmd_insert_int_3(cb, sc->sc_sync_off);
579 			udl_cmd_insert_int_1(cb, delta / 2);
580 			udl_cmd_insert_buf_le16(cb, sc->sc_fb_copy + sc->sc_sync_off, delta);
581 			sc->sc_sync_off += delta;
582 			return (cb);
583 		} else {
584 			sc->sc_sync_off += delta;
585 		}
586 	}
587 done:
588 	return (NULL);
589 }
590 
591 static void
592 udl_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
593 {
594 	struct udl_softc *sc = usbd_xfer_softc(xfer);
595 	struct udl_cmd_head *phead = usbd_xfer_get_priv(xfer);
596 	struct udl_cmd_buf *cb;
597 	unsigned i;
598 
599 	switch (USB_GET_STATE(xfer)) {
600 	case USB_ST_TRANSFERRED:
601 		TAILQ_CONCAT(&sc->sc_cmd_buf_free, phead, entry);
602 	case USB_ST_SETUP:
603 tr_setup:
604 		for (i = 0; i != UDL_CMD_MAX_FRAMES; i++) {
605 			cb = TAILQ_FIRST(&sc->sc_cmd_buf_pending);
606 			if (cb == NULL) {
607 				cb = udl_fb_synchronize_locked(sc);
608 				if (cb == NULL)
609 					break;
610 			} else {
611 				TAILQ_REMOVE(&sc->sc_cmd_buf_pending, cb, entry);
612 			}
613 			TAILQ_INSERT_TAIL(phead, cb, entry);
614 			usbd_xfer_set_frame_data(xfer, i, cb->buf, cb->off);
615 		}
616 		if (i != 0) {
617 			usbd_xfer_set_frames(xfer, i);
618 			usbd_transfer_submit(xfer);
619 		}
620 		break;
621 	default:
622 		TAILQ_CONCAT(&sc->sc_cmd_buf_free, phead, entry);
623 		if (error != USB_ERR_CANCELLED) {
624 			/* try clear stall first */
625 			usbd_xfer_set_stall(xfer);
626 			goto tr_setup;
627 		}
628 		break;
629 	}
630 	/* wakeup any waiters */
631 	cv_signal(&sc->sc_cv);
632 }
633 
634 static int
635 udl_power_save(struct udl_softc *sc, int on, int flags)
636 {
637 	struct udl_cmd_buf *cb;
638 
639 	/* get new buffer */
640 	cb = udl_cmd_buf_alloc(sc, flags);
641 	if (cb == NULL)
642 		return (EAGAIN);
643 
644 	DPRINTF("screen %s\n", on ? "ON" : "OFF");
645 
646 	sc->sc_power_save = on ? 0 : 1;
647 
648 	if (on)
649 		udl_cmd_write_reg_1(cb, UDL_REG_SCREEN, UDL_REG_SCREEN_ON);
650 	else
651 		udl_cmd_write_reg_1(cb, UDL_REG_SCREEN, UDL_REG_SCREEN_OFF);
652 
653 	udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0xff);
654 	udl_cmd_buf_send(sc, cb);
655 	return (0);
656 }
657 
658 static int
659 udl_ctrl_msg(struct udl_softc *sc, uint8_t rt, uint8_t r,
660     uint16_t index, uint16_t value, uint8_t *buf, size_t len)
661 {
662 	usb_device_request_t req;
663 	int error;
664 
665 	req.bmRequestType = rt;
666 	req.bRequest = r;
667 	USETW(req.wIndex, index);
668 	USETW(req.wValue, value);
669 	USETW(req.wLength, len);
670 
671 	error = usbd_do_request_flags(sc->sc_udev, NULL,
672 	    &req, buf, 0, NULL, USB_DEFAULT_TIMEOUT);
673 
674 	DPRINTF("%s\n", usbd_errstr(error));
675 
676 	return (error);
677 }
678 
679 static int
680 udl_poll(struct udl_softc *sc, uint32_t *buf)
681 {
682 	uint32_t lbuf;
683 	int error;
684 
685 	error = udl_ctrl_msg(sc, UT_READ_VENDOR_DEVICE,
686 	    UDL_CTRL_CMD_POLL, 0x0000, 0x0000, (uint8_t *)&lbuf, sizeof(lbuf));
687 	if (error == USB_ERR_NORMAL_COMPLETION)
688 		*buf = le32toh(lbuf);
689 	return (error);
690 }
691 
692 static int
693 udl_read_1(struct udl_softc *sc, uint16_t addr, uint8_t *buf)
694 {
695 	uint8_t lbuf[1];
696 	int error;
697 
698 	error = udl_ctrl_msg(sc, UT_READ_VENDOR_DEVICE,
699 	    UDL_CTRL_CMD_READ_1, addr, 0x0000, lbuf, 1);
700 	if (error == USB_ERR_NORMAL_COMPLETION)
701 		*buf = *(uint8_t *)lbuf;
702 	return (error);
703 }
704 
705 static int
706 udl_write_1(struct udl_softc *sc, uint16_t addr, uint8_t buf)
707 {
708 	int error;
709 
710 	error = udl_ctrl_msg(sc, UT_WRITE_VENDOR_DEVICE,
711 	    UDL_CTRL_CMD_WRITE_1, addr, 0x0000, &buf, 1);
712 	return (error);
713 }
714 
715 static int
716 udl_read_edid(struct udl_softc *sc, uint8_t *buf)
717 {
718 	uint8_t lbuf[64];
719 	uint16_t offset;
720 	int error;
721 
722 	offset = 0;
723 
724 	error = udl_ctrl_msg(sc, UT_READ_VENDOR_DEVICE,
725 	    UDL_CTRL_CMD_READ_EDID, 0x00a1, (offset << 8), lbuf, 64);
726 	if (error != USB_ERR_NORMAL_COMPLETION)
727 		goto fail;
728 	bcopy(lbuf + 1, buf + offset, 63);
729 	offset += 63;
730 
731 	error = udl_ctrl_msg(sc, UT_READ_VENDOR_DEVICE,
732 	    UDL_CTRL_CMD_READ_EDID, 0x00a1, (offset << 8), lbuf, 64);
733 	if (error != USB_ERR_NORMAL_COMPLETION)
734 		goto fail;
735 	bcopy(lbuf + 1, buf + offset, 63);
736 	offset += 63;
737 
738 	error = udl_ctrl_msg(sc, UT_READ_VENDOR_DEVICE,
739 	    UDL_CTRL_CMD_READ_EDID, 0x00a1, (offset << 8), lbuf, 3);
740 	if (error != USB_ERR_NORMAL_COMPLETION)
741 		goto fail;
742 	bcopy(lbuf + 1, buf + offset, 2);
743 fail:
744 	return (error);
745 }
746 
747 static uint8_t
748 udl_lookup_mode(uint16_t hdisplay, uint16_t vdisplay, uint8_t hz,
749     uint16_t chip, uint32_t clock)
750 {
751 	uint8_t idx;
752 
753 	/*
754 	 * Check first if we have a matching mode with pixelclock
755 	 */
756 	for (idx = 0; idx != UDL_MAX_MODES; idx++) {
757 		if ((udl_modes[idx].hdisplay == hdisplay) &&
758 		    (udl_modes[idx].vdisplay == vdisplay) &&
759 		    (udl_modes[idx].clock == clock) &&
760 		    (udl_modes[idx].chip <= chip)) {
761 			return (idx);
762 		}
763 	}
764 
765 	/*
766 	 * If not, check for matching mode with update frequency
767 	 */
768 	for (idx = 0; idx != UDL_MAX_MODES; idx++) {
769 		if ((udl_modes[idx].hdisplay == hdisplay) &&
770 		    (udl_modes[idx].vdisplay == vdisplay) &&
771 		    (udl_modes[idx].hz == hz) &&
772 		    (udl_modes[idx].chip <= chip)) {
773 			return (idx);
774 		}
775 	}
776 	return (idx);
777 }
778 
779 static void
780 udl_select_chip(struct udl_softc *sc, struct usb_attach_arg *uaa)
781 {
782 	const char *pserial;
783 
784 	pserial = usb_get_serial(uaa->device);
785 
786 	sc->sc_chip = DL120;
787 
788 	if ((uaa->info.idVendor == USB_VENDOR_DISPLAYLINK) &&
789 	    (uaa->info.idProduct == USB_PRODUCT_DISPLAYLINK_WSDVI)) {
790 
791 		/*
792 		 * WS Tech DVI is DL120 or DL160. All deviced uses the
793 		 * same revision (0.04) so iSerialNumber must be used
794 		 * to determin which chip it is.
795 		 */
796 
797 		if (strlen(pserial) > 7) {
798 			if (strncmp(pserial, "0198-13", 7) == 0)
799 				sc->sc_chip = DL160;
800 		}
801 		DPRINTF("iSerialNumber (%s) used to select chip (%d)\n",
802 		    pserial, sc->sc_chip);
803 	}
804 	if ((uaa->info.idVendor == USB_VENDOR_DISPLAYLINK) &&
805 	    (uaa->info.idProduct == USB_PRODUCT_DISPLAYLINK_SWDVI)) {
806 
807 		/*
808 		 * SUNWEIT DVI is DL160, DL125, DL165 or DL195. Major revision
809 		 * can be used to differ between DL1x0 and DL1x5. Minor to
810 		 * differ between DL1x5. iSerialNumber seems not to be uniqe.
811 		 */
812 
813 		sc->sc_chip = DL160;
814 
815 		if (uaa->info.bcdDevice >= 0x100) {
816 			sc->sc_chip = DL165;
817 			if (uaa->info.bcdDevice == 0x104)
818 				sc->sc_chip = DL195;
819 			if (uaa->info.bcdDevice == 0x108)
820 				sc->sc_chip = DL125;
821 		}
822 		DPRINTF("bcdDevice (%02x) used to select chip (%d)\n",
823 		    uaa->info.bcdDevice, sc->sc_chip);
824 	}
825 }
826 
827 static int
828 udl_set_enc_key(struct udl_softc *sc, uint8_t *buf, uint8_t len)
829 {
830 	int error;
831 
832 	error = udl_ctrl_msg(sc, UT_WRITE_VENDOR_DEVICE,
833 	    UDL_CTRL_CMD_SET_KEY, 0x0000, 0x0000, buf, len);
834 	return (error);
835 }
836 
837 static void
838 udl_fbmem_alloc(struct udl_softc *sc)
839 {
840 	uint32_t size;
841 
842 	size = udl_get_fb_size(sc);
843 	size = round_page(size);
844 	/* check for zero size */
845 	if (size == 0)
846 		size = PAGE_SIZE;
847 	/*
848 	 * It is assumed that allocations above PAGE_SIZE bytes will
849 	 * be PAGE_SIZE aligned for use with mmap()
850 	 */
851 	sc->sc_fb_addr = udl_buffer_alloc(size);
852 	sc->sc_fb_copy = malloc(size, M_USB_DL, M_WAITOK | M_ZERO);
853 	sc->sc_fb_size = size;
854 }
855 
856 static void
857 udl_cmd_insert_int_1(struct udl_cmd_buf *cb, uint8_t value)
858 {
859 
860 	cb->buf[cb->off] = value;
861 	cb->off += 1;
862 }
863 
864 #if 0
865 static void
866 udl_cmd_insert_int_2(struct udl_cmd_buf *cb, uint16_t value)
867 {
868 	uint16_t lvalue;
869 
870 	lvalue = htobe16(value);
871 	bcopy(&lvalue, cb->buf + cb->off, 2);
872 
873 	cb->off += 2;
874 }
875 
876 #endif
877 
878 static void
879 udl_cmd_insert_int_3(struct udl_cmd_buf *cb, uint32_t value)
880 {
881 	uint32_t lvalue;
882 
883 #if BYTE_ORDER == BIG_ENDIAN
884 	lvalue = htobe32(value) << 8;
885 #else
886 	lvalue = htobe32(value) >> 8;
887 #endif
888 	bcopy(&lvalue, cb->buf + cb->off, 3);
889 
890 	cb->off += 3;
891 }
892 
893 #if 0
894 static void
895 udl_cmd_insert_int_4(struct udl_cmd_buf *cb, uint32_t value)
896 {
897 	uint32_t lvalue;
898 
899 	lvalue = htobe32(value);
900 	bcopy(&lvalue, cb->buf + cb->off, 4);
901 
902 	cb->off += 4;
903 }
904 
905 #endif
906 
907 static void
908 udl_cmd_insert_buf_le16(struct udl_cmd_buf *cb, const uint8_t *buf, uint32_t len)
909 {
910 	uint32_t x;
911 
912 	for (x = 0; x != len; x += 2) {
913 		/* byte swap from little endian to big endian */
914 		cb->buf[cb->off + x + 0] = buf[x + 1];
915 		cb->buf[cb->off + x + 1] = buf[x + 0];
916 	}
917 	cb->off += len;
918 }
919 
920 static void
921 udl_cmd_write_reg_1(struct udl_cmd_buf *cb, uint8_t reg, uint8_t val)
922 {
923 
924 	udl_cmd_insert_int_1(cb, UDL_BULK_SOC);
925 	udl_cmd_insert_int_1(cb, UDL_BULK_CMD_REG_WRITE_1);
926 	udl_cmd_insert_int_1(cb, reg);
927 	udl_cmd_insert_int_1(cb, val);
928 }
929 
930 static void
931 udl_cmd_write_reg_3(struct udl_cmd_buf *cb, uint8_t reg, uint32_t val)
932 {
933 
934 	udl_cmd_write_reg_1(cb, reg + 0, (val >> 16) & 0xff);
935 	udl_cmd_write_reg_1(cb, reg + 1, (val >> 8) & 0xff);
936 	udl_cmd_write_reg_1(cb, reg + 2, (val >> 0) & 0xff);
937 }
938 
939 static int
940 udl_init_chip(struct udl_softc *sc)
941 {
942 	uint32_t ui32;
943 	uint8_t ui8;
944 	int error;
945 
946 	error = udl_poll(sc, &ui32);
947 	if (error != USB_ERR_NORMAL_COMPLETION)
948 		return (error);
949 	DPRINTF("poll=0x%08x\n", ui32);
950 
951 	/* Some products may use later chip too */
952 	switch (ui32 & 0xff) {
953 	case 0xf1:			/* DL1x5 */
954 		switch (sc->sc_chip) {
955 		case DL120:
956 			sc->sc_chip = DL125;
957 			break;
958 		case DL160:
959 			sc->sc_chip = DL165;
960 			break;
961 		}
962 		break;
963 	}
964 	DPRINTF("chip 0x%04x\n", sc->sc_chip);
965 
966 	error = udl_read_1(sc, 0xc484, &ui8);
967 	if (error != USB_ERR_NORMAL_COMPLETION)
968 		return (error);
969 	DPRINTF("read 0x%02x from 0xc484\n", ui8);
970 
971 	error = udl_write_1(sc, 0xc41f, 0x01);
972 	if (error != USB_ERR_NORMAL_COMPLETION)
973 		return (error);
974 	DPRINTF("write 0x01 to 0xc41f\n");
975 
976 	error = udl_read_edid(sc, sc->sc_edid);
977 	if (error != USB_ERR_NORMAL_COMPLETION)
978 		return (error);
979 	DPRINTF("read EDID\n");
980 
981 	error = udl_set_enc_key(sc, __DECONST(void *, udl_null_key_1),
982 	    sizeof(udl_null_key_1));
983 	if (error != USB_ERR_NORMAL_COMPLETION)
984 		return (error);
985 	DPRINTF("set encryption key\n");
986 
987 	error = udl_write_1(sc, 0xc40b, 0x00);
988 	if (error != USB_ERR_NORMAL_COMPLETION)
989 		return (error);
990 	DPRINTF("write 0x00 to 0xc40b\n");
991 
992 	return (USB_ERR_NORMAL_COMPLETION);
993 }
994 
995 static void
996 udl_init_fb_offsets(struct udl_cmd_buf *cb, uint32_t start16, uint32_t stride16,
997     uint32_t start8, uint32_t stride8)
998 {
999 	udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0x00);
1000 	udl_cmd_write_reg_3(cb, UDL_REG_ADDR_START16, start16);
1001 	udl_cmd_write_reg_3(cb, UDL_REG_ADDR_STRIDE16, stride16);
1002 	udl_cmd_write_reg_3(cb, UDL_REG_ADDR_START8, start8);
1003 	udl_cmd_write_reg_3(cb, UDL_REG_ADDR_STRIDE8, stride8);
1004 	udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0xff);
1005 }
1006 
1007 static int
1008 udl_init_resolution(struct udl_softc *sc)
1009 {
1010 	const uint32_t max = udl_get_fb_size(sc);
1011 	const uint8_t *buf = udl_modes[sc->sc_cur_mode].mode;
1012 	struct udl_cmd_buf *cb;
1013 	uint32_t delta;
1014 	uint32_t i;
1015 	int error;
1016 
1017 	/* get new buffer */
1018 	cb = udl_cmd_buf_alloc(sc, M_WAITOK);
1019 	if (cb == NULL)
1020 		return (EAGAIN);
1021 
1022 	/* write resolution values and set video memory offsets */
1023 	udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0x00);
1024 	for (i = 0; i < UDL_MODE_SIZE; i++)
1025 		udl_cmd_write_reg_1(cb, i, buf[i]);
1026 	udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0xff);
1027 
1028 	udl_init_fb_offsets(cb, 0x000000, 0x000a00, 0x555555, 0x000500);
1029 	udl_cmd_buf_send(sc, cb);
1030 
1031 	/* fill screen with black color */
1032 	for (i = 0; i < max; i += delta) {
1033 		static const uint8_t udl_black[UDL_CMD_MAX_PIXEL_COUNT * 2] __aligned(4);
1034 
1035 		delta = max - i;
1036 		if (delta > UDL_CMD_MAX_PIXEL_COUNT * 2)
1037 			delta = UDL_CMD_MAX_PIXEL_COUNT * 2;
1038 		if (i == 0)
1039 			error = udl_cmd_write_buf_le16(sc, udl_black, i, delta / 2, M_WAITOK);
1040 		else
1041 			error = udl_cmd_buf_copy_le16(sc, 0, i, delta / 2, M_WAITOK);
1042 		if (error)
1043 			return (error);
1044 	}
1045 
1046 	/* get new buffer */
1047 	cb = udl_cmd_buf_alloc(sc, M_WAITOK);
1048 	if (cb == NULL)
1049 		return (EAGAIN);
1050 
1051 	/* show framebuffer content */
1052 	udl_cmd_write_reg_1(cb, UDL_REG_SCREEN, UDL_REG_SCREEN_ON);
1053 	udl_cmd_write_reg_1(cb, UDL_REG_SYNC, 0xff);
1054 	udl_cmd_buf_send(sc, cb);
1055 	return (0);
1056 }
1057 
1058 static void
1059 udl_select_mode(struct udl_softc *sc)
1060 {
1061 	struct udl_mode mode;
1062 	int index = UDL_MAX_MODES;
1063 	int i;
1064 
1065 	/* try to get the preferred mode from EDID */
1066 	edid_parse(sc->sc_edid, &sc->sc_edid_info);
1067 #ifdef USB_DEBUG
1068 	edid_print(&sc->sc_edid_info);
1069 #endif
1070 	if (sc->sc_edid_info.edid_preferred_mode != NULL) {
1071 		mode.hz =
1072 		    (sc->sc_edid_info.edid_preferred_mode->dot_clock * 1000) /
1073 		    (sc->sc_edid_info.edid_preferred_mode->htotal *
1074 		    sc->sc_edid_info.edid_preferred_mode->vtotal);
1075 		mode.clock =
1076 		    sc->sc_edid_info.edid_preferred_mode->dot_clock / 10;
1077 		mode.hdisplay =
1078 		    sc->sc_edid_info.edid_preferred_mode->hdisplay;
1079 		mode.vdisplay =
1080 		    sc->sc_edid_info.edid_preferred_mode->vdisplay;
1081 		index = udl_lookup_mode(mode.hdisplay, mode.vdisplay, mode.hz,
1082 		    sc->sc_chip, mode.clock);
1083 		sc->sc_cur_mode = index;
1084 	} else {
1085 		DPRINTF("no preferred mode found!\n");
1086 	}
1087 
1088 	if (index == UDL_MAX_MODES) {
1089 		DPRINTF("no mode line found\n");
1090 
1091 		i = 0;
1092 		while (i < sc->sc_edid_info.edid_nmodes) {
1093 			mode.hz =
1094 			    (sc->sc_edid_info.edid_modes[i].dot_clock * 1000) /
1095 			    (sc->sc_edid_info.edid_modes[i].htotal *
1096 			    sc->sc_edid_info.edid_modes[i].vtotal);
1097 			mode.clock =
1098 			    sc->sc_edid_info.edid_modes[i].dot_clock / 10;
1099 			mode.hdisplay =
1100 			    sc->sc_edid_info.edid_modes[i].hdisplay;
1101 			mode.vdisplay =
1102 			    sc->sc_edid_info.edid_modes[i].vdisplay;
1103 			index = udl_lookup_mode(mode.hdisplay, mode.vdisplay,
1104 			    mode.hz, sc->sc_chip, mode.clock);
1105 			if (index < UDL_MAX_MODES)
1106 				if ((sc->sc_cur_mode == UDL_MAX_MODES) ||
1107 				    (index > sc->sc_cur_mode))
1108 					sc->sc_cur_mode = index;
1109 			i++;
1110 		}
1111 	}
1112 	/*
1113 	 * If no mode found use default.
1114 	 */
1115 	if (sc->sc_cur_mode == UDL_MAX_MODES)
1116 		sc->sc_cur_mode = udl_lookup_mode(800, 600, 60, sc->sc_chip, 0);
1117 }
1118 
1119 static int
1120 udl_cmd_write_buf_le16(struct udl_softc *sc, const uint8_t *buf, uint32_t off,
1121     uint8_t pixels, int flags)
1122 {
1123 	struct udl_cmd_buf *cb;
1124 
1125 	cb = udl_cmd_buf_alloc(sc, flags);
1126 	if (cb == NULL)
1127 		return (EAGAIN);
1128 
1129 	udl_cmd_insert_int_1(cb, UDL_BULK_SOC);
1130 	udl_cmd_insert_int_1(cb, UDL_BULK_CMD_FB_WRITE | UDL_BULK_CMD_FB_WORD);
1131 	udl_cmd_insert_int_3(cb, off);
1132 	udl_cmd_insert_int_1(cb, pixels);
1133 	udl_cmd_insert_buf_le16(cb, buf, 2 * pixels);
1134 	udl_cmd_buf_send(sc, cb);
1135 
1136 	return (0);
1137 }
1138 
1139 static int
1140 udl_cmd_buf_copy_le16(struct udl_softc *sc, uint32_t src, uint32_t dst,
1141     uint8_t pixels, int flags)
1142 {
1143 	struct udl_cmd_buf *cb;
1144 
1145 	cb = udl_cmd_buf_alloc(sc, flags);
1146 	if (cb == NULL)
1147 		return (EAGAIN);
1148 
1149 	udl_cmd_insert_int_1(cb, UDL_BULK_SOC);
1150 	udl_cmd_insert_int_1(cb, UDL_BULK_CMD_FB_COPY | UDL_BULK_CMD_FB_WORD);
1151 	udl_cmd_insert_int_3(cb, dst);
1152 	udl_cmd_insert_int_1(cb, pixels);
1153 	udl_cmd_insert_int_3(cb, src);
1154 	udl_cmd_buf_send(sc, cb);
1155 
1156 	return (0);
1157 }
1158