xref: /freebsd/sys/dev/usb/video/udl.c (revision 43faedc1339a9624c7acedb7f3e5624e64da5b99)
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