2 * udlfb.c -- Framebuffer driver for DisplayLink USB controller
4 * Copyright (C) 2009 Roberto De Ioris <roberto@unbit.it>
5 * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@gmail.com>
6 * Copyright (C) 2009 Bernie Thompson <bernie@plugable.com>
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License v2. See the file COPYING in the main directory of this archive for
12 * Layout is based on skeletonfb by James Simmons and Geert Uytterhoeven,
13 * usb-skeleton by GregKH.
15 * Device-specific portions based on information from Displaylink, with work
16 * from Florian Echtler, Henrik Bjerregaard Pedersen, and others.
19 #include <linux/module.h>
20 #include <linux/kernel.h>
21 #include <linux/init.h>
22 #include <linux/usb.h>
23 #include <linux/uaccess.h>
26 #include <linux/vmalloc.h>
27 #include <linux/slab.h>
31 static struct fb_fix_screeninfo dlfb_fix
= {
33 .type
= FB_TYPE_PACKED_PIXELS
,
34 .visual
= FB_VISUAL_TRUECOLOR
,
38 .accel
= FB_ACCEL_NONE
,
41 static const u32 udlfb_info_flags
= FBINFO_DEFAULT
| FBINFO_READS_FAST
|
45 FBINFO_HWACCEL_IMAGEBLIT
| FBINFO_HWACCEL_FILLRECT
|
46 FBINFO_HWACCEL_COPYAREA
| FBINFO_MISC_ALWAYS_SETPAR
;
49 * There are many DisplayLink-based products, all with unique PIDs. We are able
50 * to support all volume ones (circa 2009) with a single driver, so we match
51 * globally on VID. TODO: Probe() needs to detect when we might be running
52 * "future" chips, and bail on those, so a compatible driver can match.
54 static struct usb_device_id id_table
[] = {
55 {.idVendor
= 0x17e9, .match_flags
= USB_DEVICE_ID_MATCH_VENDOR
,},
58 MODULE_DEVICE_TABLE(usb
, id_table
);
60 #ifndef CONFIG_FB_DEFERRED_IO
61 #warning Please set CONFIG_FB_DEFFERRED_IO option to support generic fbdev apps
64 #ifndef CONFIG_FB_SYS_IMAGEBLIT
65 #ifndef CONFIG_FB_SYS_IMAGEBLIT_MODULE
66 #warning Please set CONFIG_FB_SYS_IMAGEBLIT option to support fb console
70 #ifndef CONFIG_FB_MODE_HELPERS
71 #warning CONFIG_FB_MODE_HELPERS required. Expect build break
74 /* dlfb keeps a list of urbs for efficient bulk transfers */
75 static void dlfb_urb_completion(struct urb
*urb
);
76 static struct urb
*dlfb_get_urb(struct dlfb_data
*dev
);
77 static int dlfb_submit_urb(struct dlfb_data
*dev
, struct urb
* urb
, size_t len
);
78 static int dlfb_alloc_urb_list(struct dlfb_data
*dev
, int count
, size_t size
);
79 static void dlfb_free_urb_list(struct dlfb_data
*dev
);
81 /* other symbols with dependents */
82 #ifdef CONFIG_FB_DEFERRED_IO
83 static struct fb_deferred_io dlfb_defio
;
87 * All DisplayLink bulk operations start with 0xAF, followed by specific code
88 * All operations are written to buffers which then later get sent to device
90 static char *dlfb_set_register(char *buf
, u8 reg
, u8 val
)
99 static char *dlfb_vidreg_lock(char *buf
)
101 return dlfb_set_register(buf
, 0xFF, 0x00);
104 static char *dlfb_vidreg_unlock(char *buf
)
106 return dlfb_set_register(buf
, 0xFF, 0xFF);
110 * On/Off for driving the DisplayLink framebuffer to the display
112 static char *dlfb_enable_hvsync(char *buf
, bool enable
)
115 return dlfb_set_register(buf
, 0x1F, 0x00);
117 return dlfb_set_register(buf
, 0x1F, 0x01);
120 static char *dlfb_set_color_depth(char *buf
, u8 selection
)
122 return dlfb_set_register(buf
, 0x00, selection
);
125 static char *dlfb_set_base16bpp(char *wrptr
, u32 base
)
127 /* the base pointer is 16 bits wide, 0x20 is hi byte. */
128 wrptr
= dlfb_set_register(wrptr
, 0x20, base
>> 16);
129 wrptr
= dlfb_set_register(wrptr
, 0x21, base
>> 8);
130 return dlfb_set_register(wrptr
, 0x22, base
);
134 * DisplayLink HW has separate 16bpp and 8bpp framebuffers.
135 * In 24bpp modes, the low 323 RGB bits go in the 8bpp framebuffer
137 static char *dlfb_set_base8bpp(char *wrptr
, u32 base
)
139 wrptr
= dlfb_set_register(wrptr
, 0x26, base
>> 16);
140 wrptr
= dlfb_set_register(wrptr
, 0x27, base
>> 8);
141 return dlfb_set_register(wrptr
, 0x28, base
);
144 static char *dlfb_set_register_16(char *wrptr
, u8 reg
, u16 value
)
146 wrptr
= dlfb_set_register(wrptr
, reg
, value
>> 8);
147 return dlfb_set_register(wrptr
, reg
+1, value
);
151 * This is kind of weird because the controller takes some
152 * register values in a different byte order than other registers.
154 static char *dlfb_set_register_16be(char *wrptr
, u8 reg
, u16 value
)
156 wrptr
= dlfb_set_register(wrptr
, reg
, value
);
157 return dlfb_set_register(wrptr
, reg
+1, value
>> 8);
161 * LFSR is linear feedback shift register. The reason we have this is
162 * because the display controller needs to minimize the clock depth of
163 * various counters used in the display path. So this code reverses the
164 * provided value into the lfsr16 value by counting backwards to get
165 * the value that needs to be set in the hardware comparator to get the
166 * same actual count. This makes sense once you read above a couple of
167 * times and think about it from a hardware perspective.
169 static u16
dlfb_lfsr16(u16 actual_count
)
171 u32 lv
= 0xFFFF; /* This is the lfsr value that the hw starts with */
173 while (actual_count
--) {
175 (((lv
>> 15) ^ (lv
>> 4) ^ (lv
>> 2) ^ (lv
>> 1)) & 1))
183 * This does LFSR conversion on the value that is to be written.
184 * See LFSR explanation above for more detail.
186 static char *dlfb_set_register_lfsr16(char *wrptr
, u8 reg
, u16 value
)
188 return dlfb_set_register_16(wrptr
, reg
, dlfb_lfsr16(value
));
192 * This takes a standard fbdev screeninfo struct and all of its monitor mode
193 * details and converts them into the DisplayLink equivalent register commands.
195 static char *dlfb_set_vid_cmds(char *wrptr
, struct fb_var_screeninfo
*var
)
201 /* x display start */
202 xds
= var
->left_margin
+ var
->hsync_len
;
203 wrptr
= dlfb_set_register_lfsr16(wrptr
, 0x01, xds
);
205 xde
= xds
+ var
->xres
;
206 wrptr
= dlfb_set_register_lfsr16(wrptr
, 0x03, xde
);
208 /* y display start */
209 yds
= var
->upper_margin
+ var
->vsync_len
;
210 wrptr
= dlfb_set_register_lfsr16(wrptr
, 0x05, yds
);
212 yde
= yds
+ var
->yres
;
213 wrptr
= dlfb_set_register_lfsr16(wrptr
, 0x07, yde
);
215 /* x end count is active + blanking - 1 */
216 wrptr
= dlfb_set_register_lfsr16(wrptr
, 0x09,
217 xde
+ var
->right_margin
- 1);
219 /* libdlo hardcodes hsync start to 1 */
220 wrptr
= dlfb_set_register_lfsr16(wrptr
, 0x0B, 1);
222 /* hsync end is width of sync pulse + 1 */
223 wrptr
= dlfb_set_register_lfsr16(wrptr
, 0x0D, var
->hsync_len
+ 1);
225 /* hpixels is active pixels */
226 wrptr
= dlfb_set_register_16(wrptr
, 0x0F, var
->xres
);
228 /* yendcount is vertical active + vertical blanking */
229 yec
= var
->yres
+ var
->upper_margin
+ var
->lower_margin
+
231 wrptr
= dlfb_set_register_lfsr16(wrptr
, 0x11, yec
);
233 /* libdlo hardcodes vsync start to 0 */
234 wrptr
= dlfb_set_register_lfsr16(wrptr
, 0x13, 0);
236 /* vsync end is width of vsync pulse */
237 wrptr
= dlfb_set_register_lfsr16(wrptr
, 0x15, var
->vsync_len
);
239 /* vpixels is active pixels */
240 wrptr
= dlfb_set_register_16(wrptr
, 0x17, var
->yres
);
242 /* convert picoseconds to 5kHz multiple for pclk5k = x * 1E12/5k */
243 wrptr
= dlfb_set_register_16be(wrptr
, 0x1B,
244 200*1000*1000/var
->pixclock
);
250 * This takes a standard fbdev screeninfo struct that was fetched or prepared
251 * and then generates the appropriate command sequence that then drives the
252 * display controller.
254 static int dlfb_set_video_mode(struct dlfb_data
*dev
,
255 struct fb_var_screeninfo
*var
)
263 if (!atomic_read(&dev
->usb_active
))
266 urb
= dlfb_get_urb(dev
);
269 buf
= (char *) urb
->transfer_buffer
;
272 * This first section has to do with setting the base address on the
273 * controller * associated with the display. There are 2 base
274 * pointers, currently, we only * use the 16 bpp segment.
276 wrptr
= dlfb_vidreg_lock(buf
);
277 wrptr
= dlfb_set_color_depth(wrptr
, 0x00);
278 /* set base for 16bpp segment to 0 */
279 wrptr
= dlfb_set_base16bpp(wrptr
, 0);
280 /* set base for 8bpp segment to end of fb */
281 wrptr
= dlfb_set_base8bpp(wrptr
, dev
->info
->fix
.smem_len
);
283 wrptr
= dlfb_set_vid_cmds(wrptr
, var
);
284 wrptr
= dlfb_enable_hvsync(wrptr
, true);
285 wrptr
= dlfb_vidreg_unlock(wrptr
);
287 writesize
= wrptr
- buf
;
289 retval
= dlfb_submit_urb(dev
, urb
, writesize
);
294 static int dlfb_ops_mmap(struct fb_info
*info
, struct vm_area_struct
*vma
)
296 unsigned long start
= vma
->vm_start
;
297 unsigned long size
= vma
->vm_end
- vma
->vm_start
;
298 unsigned long offset
= vma
->vm_pgoff
<< PAGE_SHIFT
;
299 unsigned long page
, pos
;
300 struct dlfb_data
*dev
= info
->par
;
302 dl_notice("MMAP: %lu %u\n", offset
+ size
, info
->fix
.smem_len
);
304 if (offset
+ size
> info
->fix
.smem_len
)
307 pos
= (unsigned long)info
->fix
.smem_start
+ offset
;
310 page
= vmalloc_to_pfn((void *)pos
);
311 if (remap_pfn_range(vma
, start
, page
, PAGE_SIZE
, PAGE_SHARED
))
316 if (size
> PAGE_SIZE
)
322 vma
->vm_flags
|= VM_RESERVED
; /* avoid to swap out this VMA */
328 * Trims identical data from front and back of line
329 * Sets new front buffer address and width
330 * And returns byte count of identical pixels
331 * Assumes CPU natural alignment (unsigned long)
332 * for back and front buffer ptrs and width
334 static int dlfb_trim_hline(const u8
*bback
, const u8
**bfront
, int *width_bytes
)
337 const unsigned long *back
= (const unsigned long *) bback
;
338 const unsigned long *front
= (const unsigned long *) *bfront
;
339 const int width
= *width_bytes
/ sizeof(unsigned long);
340 int identical
= width
;
344 prefetch((void *) front
);
345 prefetch((void *) back
);
347 for (j
= 0; j
< width
; j
++) {
348 if (back
[j
] != front
[j
]) {
354 for (k
= width
- 1; k
> j
; k
--) {
355 if (back
[k
] != front
[k
]) {
361 identical
= start
+ (width
- end
);
362 *bfront
= (u8
*) &front
[start
];
363 *width_bytes
= (end
- start
) * sizeof(unsigned long);
365 return identical
* sizeof(unsigned long);
369 * Render a command stream for an encoded horizontal line segment of pixels.
371 * A command buffer holds several commands.
372 * It always begins with a fresh command header
373 * (the protocol doesn't require this, but we enforce it to allow
374 * multiple buffers to be potentially encoded and sent in parallel).
375 * A single command encodes one contiguous horizontal line of pixels
377 * The function relies on the client to do all allocation, so that
378 * rendering can be done directly to output buffers (e.g. USB URBs).
379 * The function fills the supplied command buffer, providing information
380 * on where it left off, so the client may call in again with additional
381 * buffers if the line will take several buffers to complete.
383 * A single command can transmit a maximum of 256 pixels,
384 * regardless of the compression ratio (protocol design limit).
385 * To the hardware, 0 for a size byte means 256
387 * Rather than 256 pixel commands which are either rl or raw encoded,
388 * the rlx command simply assumes alternating raw and rl spans within one cmd.
389 * This has a slightly larger header overhead, but produces more even results.
390 * It also processes all data (read and write) in a single pass.
391 * Performance benchmarks of common cases show it having just slightly better
392 * compression than 256 pixel raw -or- rle commands, with similar CPU consumpion.
393 * But for very rl friendly data, will compress not quite as well.
395 static void dlfb_compress_hline(
396 const uint16_t **pixel_start_ptr
,
397 const uint16_t *const pixel_end
,
398 uint32_t *device_address_ptr
,
399 uint8_t **command_buffer_ptr
,
400 const uint8_t *const cmd_buffer_end
)
402 const uint16_t *pixel
= *pixel_start_ptr
;
403 uint32_t dev_addr
= *device_address_ptr
;
404 uint8_t *cmd
= *command_buffer_ptr
;
407 while ((pixel_end
> pixel
) &&
408 (cmd_buffer_end
- MIN_RLX_CMD_BYTES
> cmd
)) {
409 uint8_t *raw_pixels_count_byte
= 0;
410 uint8_t *cmd_pixels_count_byte
= 0;
411 const uint16_t *raw_pixel_start
= 0;
412 const uint16_t *cmd_pixel_start
, *cmd_pixel_end
= 0;
413 const uint32_t be_dev_addr
= cpu_to_be32(dev_addr
);
415 prefetchw((void *) cmd
); /* pull in one cache line at least */
419 *cmd
++ = (uint8_t) ((be_dev_addr
>> 8) & 0xFF);
420 *cmd
++ = (uint8_t) ((be_dev_addr
>> 16) & 0xFF);
421 *cmd
++ = (uint8_t) ((be_dev_addr
>> 24) & 0xFF);
423 cmd_pixels_count_byte
= cmd
++; /* we'll know this later */
424 cmd_pixel_start
= pixel
;
426 raw_pixels_count_byte
= cmd
++; /* we'll know this later */
427 raw_pixel_start
= pixel
;
429 cmd_pixel_end
= pixel
+ min(MAX_CMD_PIXELS
+ 1,
430 min((int)(pixel_end
- pixel
),
431 (int)(cmd_buffer_end
- cmd
) / bpp
));
433 prefetch_range((void *) pixel
, (cmd_pixel_end
- pixel
) * bpp
);
435 while (pixel
< cmd_pixel_end
) {
436 const uint16_t * const repeating_pixel
= pixel
;
438 *(uint16_t *)cmd
= cpu_to_be16p(pixel
);
442 if (unlikely((pixel
< cmd_pixel_end
) &&
443 (*pixel
== *repeating_pixel
))) {
444 /* go back and fill in raw pixel count */
445 *raw_pixels_count_byte
= ((repeating_pixel
-
446 raw_pixel_start
) + 1) & 0xFF;
448 while ((pixel
< cmd_pixel_end
)
449 && (*pixel
== *repeating_pixel
)) {
453 /* immediately after raw data is repeat byte */
454 *cmd
++ = ((pixel
- repeating_pixel
) - 1) & 0xFF;
456 /* Then start another raw pixel span */
457 raw_pixel_start
= pixel
;
458 raw_pixels_count_byte
= cmd
++;
462 if (pixel
> raw_pixel_start
) {
463 /* finalize last RAW span */
464 *raw_pixels_count_byte
= (pixel
-raw_pixel_start
) & 0xFF;
467 *cmd_pixels_count_byte
= (pixel
- cmd_pixel_start
) & 0xFF;
468 dev_addr
+= (pixel
- cmd_pixel_start
) * bpp
;
471 if (cmd_buffer_end
<= MIN_RLX_CMD_BYTES
+ cmd
) {
472 /* Fill leftover bytes with no-ops */
473 if (cmd_buffer_end
> cmd
)
474 memset(cmd
, 0xAF, cmd_buffer_end
- cmd
);
475 cmd
= (uint8_t *) cmd_buffer_end
;
478 *command_buffer_ptr
= cmd
;
479 *pixel_start_ptr
= pixel
;
480 *device_address_ptr
= dev_addr
;
486 * There are 3 copies of every pixel: The front buffer that the fbdev
487 * client renders to, the actual framebuffer across the USB bus in hardware
488 * (that we can only write to, slowly, and can never read), and (optionally)
489 * our shadow copy that tracks what's been sent to that hardware buffer.
491 static void dlfb_render_hline(struct dlfb_data
*dev
, struct urb
**urb_ptr
,
492 const char *front
, char **urb_buf_ptr
,
493 u32 byte_offset
, u32 byte_width
,
494 int *ident_ptr
, int *sent_ptr
)
496 const u8
*line_start
, *line_end
, *next_pixel
;
497 u32 dev_addr
= dev
->base16
+ byte_offset
;
498 struct urb
*urb
= *urb_ptr
;
499 u8
*cmd
= *urb_buf_ptr
;
500 u8
*cmd_end
= (u8
*) urb
->transfer_buffer
+ urb
->transfer_buffer_length
;
502 line_start
= (u8
*) (front
+ byte_offset
);
503 next_pixel
= line_start
;
504 line_end
= next_pixel
+ byte_width
;
506 if (dev
->backing_buffer
) {
508 const u8
*back_start
= (u8
*) (dev
->backing_buffer
511 *ident_ptr
+= dlfb_trim_hline(back_start
, &next_pixel
,
514 offset
= next_pixel
- line_start
;
515 line_end
= next_pixel
+ byte_width
;
517 back_start
+= offset
;
518 line_start
+= offset
;
520 memcpy((char *)back_start
, (char *) line_start
,
524 while (next_pixel
< line_end
) {
526 dlfb_compress_hline((const uint16_t **) &next_pixel
,
527 (const uint16_t *) line_end
, &dev_addr
,
528 (u8
**) &cmd
, (u8
*) cmd_end
);
530 if (cmd
>= cmd_end
) {
531 int len
= cmd
- (u8
*) urb
->transfer_buffer
;
532 if (dlfb_submit_urb(dev
, urb
, len
))
533 return; /* lost pixels is set */
535 urb
= dlfb_get_urb(dev
);
537 return; /* lost_pixels is set */
539 cmd
= urb
->transfer_buffer
;
540 cmd_end
= &cmd
[urb
->transfer_buffer_length
];
547 int dlfb_handle_damage(struct dlfb_data
*dev
, int x
, int y
,
548 int width
, int height
, char *data
)
552 cycles_t start_cycles
, end_cycles
;
554 int bytes_identical
= 0;
558 start_cycles
= get_cycles();
560 aligned_x
= DL_ALIGN_DOWN(x
, sizeof(unsigned long));
561 width
= DL_ALIGN_UP(width
+ (x
-aligned_x
), sizeof(unsigned long));
565 (x
+ width
> dev
->info
->var
.xres
) ||
566 (y
+ height
> dev
->info
->var
.yres
))
569 if (!atomic_read(&dev
->usb_active
))
572 urb
= dlfb_get_urb(dev
);
575 cmd
= urb
->transfer_buffer
;
577 for (i
= y
; i
< y
+ height
; i
++) {
578 const int line_offset
= dev
->info
->fix
.line_length
* i
;
579 const int byte_offset
= line_offset
+ (x
* BPP
);
581 dlfb_render_hline(dev
, &urb
, (char *) dev
->info
->fix
.smem_start
,
582 &cmd
, byte_offset
, width
* BPP
,
583 &bytes_identical
, &bytes_sent
);
586 if (cmd
> (char *) urb
->transfer_buffer
) {
587 /* Send partial buffer remaining before exiting */
588 int len
= cmd
- (char *) urb
->transfer_buffer
;
589 ret
= dlfb_submit_urb(dev
, urb
, len
);
592 dlfb_urb_completion(urb
);
594 atomic_add(bytes_sent
, &dev
->bytes_sent
);
595 atomic_add(bytes_identical
, &dev
->bytes_identical
);
596 atomic_add(width
*height
*2, &dev
->bytes_rendered
);
597 end_cycles
= get_cycles();
598 atomic_add(((unsigned int) ((end_cycles
- start_cycles
)
599 >> 10)), /* Kcycles */
600 &dev
->cpu_kcycles_used
);
605 /* hardware has native COPY command (see libdlo), but not worth it for fbcon */
606 static void dlfb_ops_copyarea(struct fb_info
*info
,
607 const struct fb_copyarea
*area
)
610 struct dlfb_data
*dev
= info
->par
;
612 #if defined CONFIG_FB_SYS_COPYAREA || defined CONFIG_FB_SYS_COPYAREA_MODULE
614 sys_copyarea(info
, area
);
616 dlfb_handle_damage(dev
, area
->dx
, area
->dy
,
617 area
->width
, area
->height
, info
->screen_base
);
619 atomic_inc(&dev
->copy_count
);
623 static void dlfb_ops_imageblit(struct fb_info
*info
,
624 const struct fb_image
*image
)
626 struct dlfb_data
*dev
= info
->par
;
628 #if defined CONFIG_FB_SYS_IMAGEBLIT || defined CONFIG_FB_SYS_IMAGEBLIT_MODULE
630 sys_imageblit(info
, image
);
632 dlfb_handle_damage(dev
, image
->dx
, image
->dy
,
633 image
->width
, image
->height
, info
->screen_base
);
637 atomic_inc(&dev
->blit_count
);
640 static void dlfb_ops_fillrect(struct fb_info
*info
,
641 const struct fb_fillrect
*rect
)
643 struct dlfb_data
*dev
= info
->par
;
645 #if defined CONFIG_FB_SYS_FILLRECT || defined CONFIG_FB_SYS_FILLRECT_MODULE
647 sys_fillrect(info
, rect
);
649 dlfb_handle_damage(dev
, rect
->dx
, rect
->dy
, rect
->width
,
650 rect
->height
, info
->screen_base
);
653 atomic_inc(&dev
->fill_count
);
657 static void dlfb_get_edid(struct dlfb_data
*dev
)
663 for (i
= 0; i
< sizeof(dev
->edid
); i
++) {
664 ret
= usb_control_msg(dev
->udev
,
665 usb_rcvctrlpipe(dev
->udev
, 0), (0x02),
666 (0x80 | (0x02 << 5)), i
<< 8, 0xA1, rbuf
, 2,
668 dev
->edid
[i
] = rbuf
[1];
672 static int dlfb_ops_ioctl(struct fb_info
*info
, unsigned int cmd
,
676 struct dlfb_data
*dev
= info
->par
;
677 struct dloarea
*area
= NULL
;
679 if (!atomic_read(&dev
->usb_active
))
682 /* TODO: Update X server to get this from sysfs instead */
683 if (cmd
== DLFB_IOCTL_RETURN_EDID
) {
684 char *edid
= (char *)arg
;
686 if (copy_to_user(edid
, dev
->edid
, sizeof(dev
->edid
)))
691 /* TODO: Help propose a standard fb.h ioctl to report mmap damage */
692 if (cmd
== DLFB_IOCTL_REPORT_DAMAGE
) {
694 area
= (struct dloarea
*)arg
;
699 if (area
->x
> info
->var
.xres
)
700 area
->x
= info
->var
.xres
;
705 if (area
->y
> info
->var
.yres
)
706 area
->y
= info
->var
.yres
;
708 atomic_set(&dev
->use_defio
, 0);
710 dlfb_handle_damage(dev
, area
->x
, area
->y
, area
->w
, area
->h
,
712 atomic_inc(&dev
->damage_count
);
718 /* taken from vesafb */
720 dlfb_ops_setcolreg(unsigned regno
, unsigned red
, unsigned green
,
721 unsigned blue
, unsigned transp
, struct fb_info
*info
)
725 if (regno
>= info
->cmap
.len
)
729 if (info
->var
.red
.offset
== 10) {
731 ((u32
*) (info
->pseudo_palette
))[regno
] =
732 ((red
& 0xf800) >> 1) |
733 ((green
& 0xf800) >> 6) | ((blue
& 0xf800) >> 11);
736 ((u32
*) (info
->pseudo_palette
))[regno
] =
738 ((green
& 0xfc00) >> 5) | ((blue
& 0xf800) >> 11);
746 * It's common for several clients to have framebuffer open simultaneously.
747 * e.g. both fbcon and X. Makes things interesting.
749 static int dlfb_ops_open(struct fb_info
*info
, int user
)
751 struct dlfb_data
*dev
= info
->par
;
754 * We could special case kernel mode clients (fbcon) here
757 mutex_lock(&dev
->fb_open_lock
);
761 #ifdef CONFIG_FB_DEFERRED_IO
762 if ((atomic_read(&dev
->use_defio
)) && (info
->fbdefio
== NULL
)) {
764 info
->fbdefio
= &dlfb_defio
;
765 fb_deferred_io_init(info
);
769 dl_notice("open /dev/fb%d user=%d fb_info=%p count=%d\n",
770 info
->node
, user
, info
, dev
->fb_count
);
772 mutex_unlock(&dev
->fb_open_lock
);
777 static int dlfb_ops_release(struct fb_info
*info
, int user
)
779 struct dlfb_data
*dev
= info
->par
;
781 mutex_lock(&dev
->fb_open_lock
);
785 #ifdef CONFIG_FB_DEFERRED_IO
786 if ((dev
->fb_count
== 0) && (info
->fbdefio
)) {
787 fb_deferred_io_cleanup(info
);
788 info
->fbdefio
= NULL
;
789 info
->fbops
->fb_mmap
= dlfb_ops_mmap
;
793 dl_notice("release /dev/fb%d user=%d count=%d\n",
794 info
->node
, user
, dev
->fb_count
);
796 mutex_unlock(&dev
->fb_open_lock
);
802 * Called when all client interfaces to start transactions have been disabled,
803 * and all references to our device instance (dlfb_data) are released.
804 * Every transaction must have a reference, so we know are fully spun down
806 static void dlfb_delete(struct kref
*kref
)
808 struct dlfb_data
*dev
= container_of(kref
, struct dlfb_data
, kref
);
810 if (dev
->backing_buffer
)
811 vfree(dev
->backing_buffer
);
813 mutex_destroy(&dev
->fb_open_lock
);
819 * Called by fbdev as last part of unregister_framebuffer() process
820 * No new clients can open connections. Deallocate everything fb_info.
822 static void dlfb_ops_destroy(struct fb_info
*info
)
824 struct dlfb_data
*dev
= info
->par
;
826 if (info
->cmap
.len
!= 0)
827 fb_dealloc_cmap(&info
->cmap
);
828 if (info
->monspecs
.modedb
)
829 fb_destroy_modedb(info
->monspecs
.modedb
);
830 if (info
->screen_base
)
831 vfree(info
->screen_base
);
833 fb_destroy_modelist(&info
->modelist
);
835 framebuffer_release(info
);
837 /* ref taken before register_framebuffer() for dlfb_data clients */
838 kref_put(&dev
->kref
, dlfb_delete
);
842 * Check whether a video mode is supported by the DisplayLink chip
843 * We start from monitor's modes, so don't need to filter that here
845 static int dlfb_is_valid_mode(struct fb_videomode
*mode
,
846 struct fb_info
*info
)
848 struct dlfb_data
*dev
= info
->par
;
850 if (mode
->xres
* mode
->yres
> dev
->sku_pixel_limit
)
856 static void dlfb_var_color_format(struct fb_var_screeninfo
*var
)
858 const struct fb_bitfield red
= { 11, 5, 0 };
859 const struct fb_bitfield green
= { 5, 6, 0 };
860 const struct fb_bitfield blue
= { 0, 5, 0 };
862 var
->bits_per_pixel
= 16;
868 static int dlfb_ops_check_var(struct fb_var_screeninfo
*var
,
869 struct fb_info
*info
)
871 struct fb_videomode mode
;
873 /* TODO: support dynamically changing framebuffer size */
874 if ((var
->xres
* var
->yres
* 2) > info
->fix
.smem_len
)
877 /* set device-specific elements of var unrelated to mode */
878 dlfb_var_color_format(var
);
880 fb_var_to_videomode(&mode
, var
);
882 if (!dlfb_is_valid_mode(&mode
, info
))
888 static int dlfb_ops_set_par(struct fb_info
*info
)
890 struct dlfb_data
*dev
= info
->par
;
892 dl_notice("set_par mode %dx%d\n", info
->var
.xres
, info
->var
.yres
);
894 return dlfb_set_video_mode(dev
, &info
->var
);
897 static int dlfb_ops_blank(int blank_mode
, struct fb_info
*info
)
899 struct dlfb_data
*dev
= info
->par
;
903 urb
= dlfb_get_urb(dev
);
906 bufptr
= (char *) urb
->transfer_buffer
;
908 /* overloading usb_active. UNBLANK can conflict with teardown */
910 bufptr
= dlfb_vidreg_lock(bufptr
);
911 if (blank_mode
!= FB_BLANK_UNBLANK
) {
912 atomic_set(&dev
->usb_active
, 0);
913 bufptr
= dlfb_enable_hvsync(bufptr
, false);
915 atomic_set(&dev
->usb_active
, 1);
916 bufptr
= dlfb_enable_hvsync(bufptr
, true);
918 bufptr
= dlfb_vidreg_unlock(bufptr
);
920 dlfb_submit_urb(dev
, urb
, bufptr
- (char *) urb
->transfer_buffer
);
925 static struct fb_ops dlfb_ops
= {
926 .owner
= THIS_MODULE
,
927 .fb_setcolreg
= dlfb_ops_setcolreg
,
928 .fb_fillrect
= dlfb_ops_fillrect
,
929 .fb_copyarea
= dlfb_ops_copyarea
,
930 .fb_imageblit
= dlfb_ops_imageblit
,
931 .fb_mmap
= dlfb_ops_mmap
,
932 .fb_ioctl
= dlfb_ops_ioctl
,
933 .fb_open
= dlfb_ops_open
,
934 .fb_release
= dlfb_ops_release
,
935 .fb_blank
= dlfb_ops_blank
,
936 .fb_check_var
= dlfb_ops_check_var
,
937 .fb_set_par
= dlfb_ops_set_par
,
941 * Calls dlfb_get_edid() to query the EDID of attached monitor via usb cmds
942 * Then parses EDID into three places used by various parts of fbdev:
943 * fb_var_screeninfo contains the timing of the monitor's preferred mode
944 * fb_info.monspecs is full parsed EDID info, including monspecs.modedb
945 * fb_info.modelist is a linked list of all monitor & VESA modes which work
947 * If EDID is not readable/valid, then modelist is all VESA modes,
948 * monspecs is NULL, and fb_var_screeninfo is set to safe VESA mode
949 * Returns 0 if EDID parses successfully
951 static int dlfb_parse_edid(struct dlfb_data
*dev
,
952 struct fb_var_screeninfo
*var
,
953 struct fb_info
*info
)
956 const struct fb_videomode
*default_vmode
= NULL
;
959 fb_destroy_modelist(&info
->modelist
);
960 memset(&info
->monspecs
, 0, sizeof(info
->monspecs
));
963 fb_edid_to_monspecs(dev
->edid
, &info
->monspecs
);
965 if (info
->monspecs
.modedb_len
> 0) {
967 for (i
= 0; i
< info
->monspecs
.modedb_len
; i
++) {
968 if (dlfb_is_valid_mode(&info
->monspecs
.modedb
[i
], info
))
969 fb_add_videomode(&info
->monspecs
.modedb
[i
],
973 default_vmode
= fb_find_best_display(&info
->monspecs
,
976 struct fb_videomode fb_vmode
= {0};
978 dl_err("Unable to get valid EDID from device/display\n");
982 * Add the standard VESA modes to our modelist
983 * Since we don't have EDID, there may be modes that
984 * overspec monitor and/or are incorrect aspect ratio, etc.
985 * But at least the user has a chance to choose
987 for (i
= 0; i
< VESA_MODEDB_SIZE
; i
++) {
988 if (dlfb_is_valid_mode((struct fb_videomode
*)
989 &vesa_modes
[i
], info
))
990 fb_add_videomode(&vesa_modes
[i
],
995 * default to resolution safe for projectors
996 * (since they are most common case without EDID)
1000 fb_vmode
.refresh
= 60;
1001 default_vmode
= fb_find_nearest_mode(&fb_vmode
,
1005 fb_videomode_to_var(var
, default_vmode
);
1006 dlfb_var_color_format(var
);
1011 static ssize_t
metrics_bytes_rendered_show(struct device
*fbdev
,
1012 struct device_attribute
*a
, char *buf
) {
1013 struct fb_info
*fb_info
= dev_get_drvdata(fbdev
);
1014 struct dlfb_data
*dev
= fb_info
->par
;
1015 return snprintf(buf
, PAGE_SIZE
, "%u\n",
1016 atomic_read(&dev
->bytes_rendered
));
1019 static ssize_t
metrics_bytes_identical_show(struct device
*fbdev
,
1020 struct device_attribute
*a
, char *buf
) {
1021 struct fb_info
*fb_info
= dev_get_drvdata(fbdev
);
1022 struct dlfb_data
*dev
= fb_info
->par
;
1023 return snprintf(buf
, PAGE_SIZE
, "%u\n",
1024 atomic_read(&dev
->bytes_identical
));
1027 static ssize_t
metrics_bytes_sent_show(struct device
*fbdev
,
1028 struct device_attribute
*a
, char *buf
) {
1029 struct fb_info
*fb_info
= dev_get_drvdata(fbdev
);
1030 struct dlfb_data
*dev
= fb_info
->par
;
1031 return snprintf(buf
, PAGE_SIZE
, "%u\n",
1032 atomic_read(&dev
->bytes_sent
));
1035 static ssize_t
metrics_cpu_kcycles_used_show(struct device
*fbdev
,
1036 struct device_attribute
*a
, char *buf
) {
1037 struct fb_info
*fb_info
= dev_get_drvdata(fbdev
);
1038 struct dlfb_data
*dev
= fb_info
->par
;
1039 return snprintf(buf
, PAGE_SIZE
, "%u\n",
1040 atomic_read(&dev
->cpu_kcycles_used
));
1043 static ssize_t
metrics_misc_show(struct device
*fbdev
,
1044 struct device_attribute
*a
, char *buf
) {
1045 struct fb_info
*fb_info
= dev_get_drvdata(fbdev
);
1046 struct dlfb_data
*dev
= fb_info
->par
;
1047 return snprintf(buf
, PAGE_SIZE
,
1048 "Calls to\ndamage: %u\nblit: %u\n"
1049 "defio faults: %u\ncopy: %u\n"
1051 "active framebuffer clients: %d\n"
1052 "urbs available %d(%d)\n"
1053 "Shadow framebuffer in use? %s\n"
1054 "Any lost pixels? %s\n",
1055 atomic_read(&dev
->damage_count
),
1056 atomic_read(&dev
->blit_count
),
1057 atomic_read(&dev
->defio_fault_count
),
1058 atomic_read(&dev
->copy_count
),
1059 atomic_read(&dev
->fill_count
),
1061 dev
->urbs
.available
, dev
->urbs
.limit_sem
.count
,
1062 (dev
->backing_buffer
) ? "yes" : "no",
1063 atomic_read(&dev
->lost_pixels
) ? "yes" : "no");
1066 static ssize_t
edid_show(struct file
*filp
, struct kobject
*kobj
,
1067 struct bin_attribute
*a
,
1068 char *buf
, loff_t off
, size_t count
) {
1069 struct device
*fbdev
= container_of(kobj
, struct device
, kobj
);
1070 struct fb_info
*fb_info
= dev_get_drvdata(fbdev
);
1071 struct dlfb_data
*dev
= fb_info
->par
;
1072 char *edid
= &dev
->edid
[0];
1073 const size_t size
= sizeof(dev
->edid
);
1075 if (dlfb_parse_edid(dev
, &fb_info
->var
, fb_info
))
1081 if (off
+ count
> size
)
1083 memcpy(buf
, edid
+ off
, count
);
1089 static ssize_t
metrics_reset_store(struct device
*fbdev
,
1090 struct device_attribute
*attr
,
1091 const char *buf
, size_t count
)
1093 struct fb_info
*fb_info
= dev_get_drvdata(fbdev
);
1094 struct dlfb_data
*dev
= fb_info
->par
;
1096 atomic_set(&dev
->bytes_rendered
, 0);
1097 atomic_set(&dev
->bytes_identical
, 0);
1098 atomic_set(&dev
->bytes_sent
, 0);
1099 atomic_set(&dev
->cpu_kcycles_used
, 0);
1100 atomic_set(&dev
->blit_count
, 0);
1101 atomic_set(&dev
->copy_count
, 0);
1102 atomic_set(&dev
->fill_count
, 0);
1103 atomic_set(&dev
->defio_fault_count
, 0);
1104 atomic_set(&dev
->damage_count
, 0);
1109 static ssize_t
use_defio_show(struct device
*fbdev
,
1110 struct device_attribute
*a
, char *buf
) {
1111 struct fb_info
*fb_info
= dev_get_drvdata(fbdev
);
1112 struct dlfb_data
*dev
= fb_info
->par
;
1113 return snprintf(buf
, PAGE_SIZE
, "%d\n",
1114 atomic_read(&dev
->use_defio
));
1117 static ssize_t
use_defio_store(struct device
*fbdev
,
1118 struct device_attribute
*attr
,
1119 const char *buf
, size_t count
)
1121 struct fb_info
*fb_info
= dev_get_drvdata(fbdev
);
1122 struct dlfb_data
*dev
= fb_info
->par
;
1126 atomic_set(&dev
->use_defio
, 0);
1128 atomic_set(&dev
->use_defio
, 1);
1133 static struct bin_attribute edid_attr
= {
1134 .attr
.name
= "edid",
1140 static struct device_attribute fb_device_attrs
[] = {
1141 __ATTR_RO(metrics_bytes_rendered
),
1142 __ATTR_RO(metrics_bytes_identical
),
1143 __ATTR_RO(metrics_bytes_sent
),
1144 __ATTR_RO(metrics_cpu_kcycles_used
),
1145 __ATTR_RO(metrics_misc
),
1146 __ATTR(metrics_reset
, S_IWUGO
, NULL
, metrics_reset_store
),
1147 __ATTR_RW(use_defio
),
1150 #ifdef CONFIG_FB_DEFERRED_IO
1151 static void dlfb_dpy_deferred_io(struct fb_info
*info
,
1152 struct list_head
*pagelist
)
1155 struct fb_deferred_io
*fbdefio
= info
->fbdefio
;
1156 struct dlfb_data
*dev
= info
->par
;
1159 cycles_t start_cycles
, end_cycles
;
1161 int bytes_identical
= 0;
1162 int bytes_rendered
= 0;
1163 int fault_count
= 0;
1165 if (!atomic_read(&dev
->use_defio
))
1168 if (!atomic_read(&dev
->usb_active
))
1171 start_cycles
= get_cycles();
1173 urb
= dlfb_get_urb(dev
);
1176 cmd
= urb
->transfer_buffer
;
1178 /* walk the written page list and render each to device */
1179 list_for_each_entry(cur
, &fbdefio
->pagelist
, lru
) {
1180 dlfb_render_hline(dev
, &urb
, (char *) info
->fix
.smem_start
,
1181 &cmd
, cur
->index
<< PAGE_SHIFT
,
1182 PAGE_SIZE
, &bytes_identical
, &bytes_sent
);
1183 bytes_rendered
+= PAGE_SIZE
;
1187 if (cmd
> (char *) urb
->transfer_buffer
) {
1188 /* Send partial buffer remaining before exiting */
1189 int len
= cmd
- (char *) urb
->transfer_buffer
;
1190 dlfb_submit_urb(dev
, urb
, len
);
1193 dlfb_urb_completion(urb
);
1195 atomic_add(fault_count
, &dev
->defio_fault_count
);
1196 atomic_add(bytes_sent
, &dev
->bytes_sent
);
1197 atomic_add(bytes_identical
, &dev
->bytes_identical
);
1198 atomic_add(bytes_rendered
, &dev
->bytes_rendered
);
1199 end_cycles
= get_cycles();
1200 atomic_add(((unsigned int) ((end_cycles
- start_cycles
)
1201 >> 10)), /* Kcycles */
1202 &dev
->cpu_kcycles_used
);
1205 static struct fb_deferred_io dlfb_defio
= {
1207 .deferred_io
= dlfb_dpy_deferred_io
,
1213 * This is necessary before we can communicate with the display controller.
1215 static int dlfb_select_std_channel(struct dlfb_data
*dev
)
1218 u8 set_def_chn
[] = { 0x57, 0xCD, 0xDC, 0xA7,
1219 0x1C, 0x88, 0x5E, 0x15,
1220 0x60, 0xFE, 0xC6, 0x97,
1221 0x16, 0x3D, 0x47, 0xF2 };
1223 ret
= usb_control_msg(dev
->udev
, usb_sndctrlpipe(dev
->udev
, 0),
1224 NR_USB_REQUEST_CHANNEL
,
1225 (USB_DIR_OUT
| USB_TYPE_VENDOR
), 0, 0,
1226 set_def_chn
, sizeof(set_def_chn
), USB_CTRL_SET_TIMEOUT
);
1231 static int dlfb_usb_probe(struct usb_interface
*interface
,
1232 const struct usb_device_id
*id
)
1234 struct usb_device
*usbdev
;
1235 struct dlfb_data
*dev
;
1236 struct fb_info
*info
;
1237 int videomemorysize
;
1239 unsigned char *videomemory
;
1240 int retval
= -ENOMEM
;
1241 struct fb_var_screeninfo
*var
;
1243 u16
*pix_framebuffer
;
1245 /* usb initialization */
1247 usbdev
= interface_to_usbdev(interface
);
1249 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
1251 err("dlfb_usb_probe: failed alloc of dev struct\n");
1255 /* we need to wait for both usb and fbdev to spin down on disconnect */
1256 kref_init(&dev
->kref
); /* matching kref_put in usb .disconnect fn */
1257 kref_get(&dev
->kref
); /* matching kref_put in .fb_destroy function*/
1260 dev
->gdev
= &usbdev
->dev
; /* our generic struct device * */
1261 usb_set_intfdata(interface
, dev
);
1263 if (!dlfb_alloc_urb_list(dev
, WRITES_IN_FLIGHT
, MAX_TRANSFER
)) {
1265 dl_err("dlfb_alloc_urb_list failed\n");
1269 mutex_init(&dev
->fb_open_lock
);
1271 /* We don't register a new USB class. Our client interface is fbdev */
1273 /* allocates framebuffer driver structure, not framebuffer memory */
1274 info
= framebuffer_alloc(0, &usbdev
->dev
);
1277 dl_err("framebuffer_alloc failed\n");
1282 info
->pseudo_palette
= dev
->pseudo_palette
;
1283 info
->fbops
= &dlfb_ops
;
1287 /* TODO set limit based on actual SKU detection */
1288 dev
->sku_pixel_limit
= 2048 * 1152;
1290 INIT_LIST_HEAD(&info
->modelist
);
1291 dlfb_parse_edid(dev
, var
, info
);
1294 * ok, now that we've got the size info, we can alloc our framebuffer.
1296 info
->fix
= dlfb_fix
;
1297 info
->fix
.line_length
= var
->xres
* (var
->bits_per_pixel
/ 8);
1298 videomemorysize
= info
->fix
.line_length
* var
->yres
;
1301 * The big chunk of system memory we use as a virtual framebuffer.
1302 * TODO: Handle fbcon cursor code calling blit in interrupt context
1304 videomemory
= vmalloc(videomemorysize
);
1307 dl_err("Virtual framebuffer alloc failed\n");
1311 info
->screen_base
= videomemory
;
1312 info
->fix
.smem_len
= PAGE_ALIGN(videomemorysize
);
1313 info
->fix
.smem_start
= (unsigned long) videomemory
;
1314 info
->flags
= udlfb_info_flags
;
1318 * Second framebuffer copy, mirroring the state of the framebuffer
1319 * on the physical USB device. We can function without this.
1320 * But with imperfect damage info we may end up sending pixels over USB
1321 * that were, in fact, unchanged -- wasting limited USB bandwidth
1323 dev
->backing_buffer
= vmalloc(videomemorysize
);
1324 if (!dev
->backing_buffer
)
1325 dl_warn("No shadow/backing buffer allcoated\n");
1327 memset(dev
->backing_buffer
, 0, videomemorysize
);
1329 retval
= fb_alloc_cmap(&info
->cmap
, 256, 0);
1331 dl_err("fb_alloc_cmap failed %x\n", retval
);
1335 /* ready to begin using device */
1337 #ifdef CONFIG_FB_DEFERRED_IO
1338 atomic_set(&dev
->use_defio
, 1);
1340 atomic_set(&dev
->usb_active
, 1);
1341 dlfb_select_std_channel(dev
);
1343 dlfb_ops_check_var(var
, info
);
1344 dlfb_ops_set_par(info
);
1346 /* paint greenscreen */
1347 pix_framebuffer
= (u16
*) videomemory
;
1348 for (i
= 0; i
< videomemorysize
/ 2; i
++)
1349 pix_framebuffer
[i
] = 0x37e6;
1351 dlfb_handle_damage(dev
, 0, 0, info
->var
.xres
, info
->var
.yres
,
1354 retval
= register_framebuffer(info
);
1356 dl_err("register_framebuffer failed %d\n", retval
);
1361 for (i
= 0; i
< ARRAY_SIZE(fb_device_attrs
); i
++)
1362 device_create_file(info
->dev
, &fb_device_attrs
[i
]);
1364 device_create_bin_file(info
->dev
, &edid_attr
);
1366 dl_err("DisplayLink USB device /dev/fb%d attached. %dx%d resolution."
1367 " Using %dK framebuffer memory\n", info
->node
,
1368 var
->xres
, var
->yres
,
1369 ((dev
->backing_buffer
) ?
1370 videomemorysize
* 2 : videomemorysize
) >> 10);
1376 unregister_framebuffer(info
);
1377 dlfb_ops_destroy(info
);
1379 kref_put(&dev
->kref
, dlfb_delete
);
1381 if (dev
->urbs
.count
> 0)
1382 dlfb_free_urb_list(dev
);
1383 kref_put(&dev
->kref
, dlfb_delete
); /* last ref from kref_init */
1385 /* dev has been deallocated. Do not dereference */
1391 static void dlfb_usb_disconnect(struct usb_interface
*interface
)
1393 struct dlfb_data
*dev
;
1394 struct fb_info
*info
;
1397 dev
= usb_get_intfdata(interface
);
1400 /* when non-active we'll update virtual framebuffer, but no new urbs */
1401 atomic_set(&dev
->usb_active
, 0);
1403 usb_set_intfdata(interface
, NULL
);
1405 for (i
= 0; i
< ARRAY_SIZE(fb_device_attrs
); i
++)
1406 device_remove_file(info
->dev
, &fb_device_attrs
[i
]);
1408 device_remove_bin_file(info
->dev
, &edid_attr
);
1410 /* this function will wait for all in-flight urbs to complete */
1411 dlfb_free_urb_list(dev
);
1414 dl_notice("Detaching /dev/fb%d\n", info
->node
);
1415 unregister_framebuffer(info
);
1416 dlfb_ops_destroy(info
);
1419 /* release reference taken by kref_init in probe() */
1420 kref_put(&dev
->kref
, dlfb_delete
);
1422 /* consider dlfb_data freed */
1427 static struct usb_driver dlfb_driver
= {
1429 .probe
= dlfb_usb_probe
,
1430 .disconnect
= dlfb_usb_disconnect
,
1431 .id_table
= id_table
,
1434 static int __init
dlfb_module_init(void)
1438 res
= usb_register(&dlfb_driver
);
1440 err("usb_register failed. Error number %d", res
);
1442 printk(KERN_INFO
"VMODES initialized\n");
1447 static void __exit
dlfb_module_exit(void)
1449 usb_deregister(&dlfb_driver
);
1452 module_init(dlfb_module_init
);
1453 module_exit(dlfb_module_exit
);
1455 static void dlfb_urb_completion(struct urb
*urb
)
1457 struct urb_node
*unode
= urb
->context
;
1458 struct dlfb_data
*dev
= unode
->dev
;
1459 unsigned long flags
;
1461 /* sync/async unlink faults aren't errors */
1463 if (!(urb
->status
== -ENOENT
||
1464 urb
->status
== -ECONNRESET
||
1465 urb
->status
== -ESHUTDOWN
)) {
1466 dl_err("%s - nonzero write bulk status received: %d\n",
1467 __func__
, urb
->status
);
1468 atomic_set(&dev
->lost_pixels
, 1);
1472 urb
->transfer_buffer_length
= dev
->urbs
.size
; /* reset to actual */
1474 spin_lock_irqsave(&dev
->urbs
.lock
, flags
);
1475 list_add_tail(&unode
->entry
, &dev
->urbs
.list
);
1476 dev
->urbs
.available
++;
1477 spin_unlock_irqrestore(&dev
->urbs
.lock
, flags
);
1479 up(&dev
->urbs
.limit_sem
);
1482 static void dlfb_free_urb_list(struct dlfb_data
*dev
)
1484 int count
= dev
->urbs
.count
;
1485 struct list_head
*node
;
1486 struct urb_node
*unode
;
1489 unsigned long flags
;
1491 dl_notice("Waiting for completes and freeing all render urbs\n");
1493 /* keep waiting and freeing, until we've got 'em all */
1495 /* Timeout means a memory leak and/or fault */
1496 ret
= down_timeout(&dev
->urbs
.limit_sem
, FREE_URB_TIMEOUT
);
1501 spin_lock_irqsave(&dev
->urbs
.lock
, flags
);
1503 node
= dev
->urbs
.list
.next
; /* have reserved one with sem */
1504 list_del_init(node
);
1506 spin_unlock_irqrestore(&dev
->urbs
.lock
, flags
);
1508 unode
= list_entry(node
, struct urb_node
, entry
);
1511 /* Free each separately allocated piece */
1512 usb_free_coherent(urb
->dev
, dev
->urbs
.size
,
1513 urb
->transfer_buffer
, urb
->transfer_dma
);
1518 kref_put(&dev
->kref
, dlfb_delete
);
1522 static int dlfb_alloc_urb_list(struct dlfb_data
*dev
, int count
, size_t size
)
1526 struct urb_node
*unode
;
1529 spin_lock_init(&dev
->urbs
.lock
);
1531 dev
->urbs
.size
= size
;
1532 INIT_LIST_HEAD(&dev
->urbs
.list
);
1535 unode
= kzalloc(sizeof(struct urb_node
), GFP_KERNEL
);
1540 urb
= usb_alloc_urb(0, GFP_KERNEL
);
1547 buf
= usb_alloc_coherent(dev
->udev
, MAX_TRANSFER
, GFP_KERNEL
,
1548 &urb
->transfer_dma
);
1555 /* urb->transfer_buffer_length set to actual before submit */
1556 usb_fill_bulk_urb(urb
, dev
->udev
, usb_sndbulkpipe(dev
->udev
, 1),
1557 buf
, size
, dlfb_urb_completion
, unode
);
1558 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1560 list_add_tail(&unode
->entry
, &dev
->urbs
.list
);
1565 sema_init(&dev
->urbs
.limit_sem
, i
);
1566 dev
->urbs
.count
= i
;
1567 dev
->urbs
.available
= i
;
1569 kref_get(&dev
->kref
); /* released in free_render_urbs() */
1571 dl_notice("allocated %d %d byte urbs\n", i
, (int) size
);
1576 static struct urb
*dlfb_get_urb(struct dlfb_data
*dev
)
1579 struct list_head
*entry
;
1580 struct urb_node
*unode
;
1581 struct urb
*urb
= NULL
;
1582 unsigned long flags
;
1584 /* Wait for an in-flight buffer to complete and get re-queued */
1585 ret
= down_timeout(&dev
->urbs
.limit_sem
, GET_URB_TIMEOUT
);
1587 atomic_set(&dev
->lost_pixels
, 1);
1588 dl_err("wait for urb interrupted: %x\n", ret
);
1592 spin_lock_irqsave(&dev
->urbs
.lock
, flags
);
1594 BUG_ON(list_empty(&dev
->urbs
.list
)); /* reserved one with limit_sem */
1595 entry
= dev
->urbs
.list
.next
;
1596 list_del_init(entry
);
1597 dev
->urbs
.available
--;
1599 spin_unlock_irqrestore(&dev
->urbs
.lock
, flags
);
1601 unode
= list_entry(entry
, struct urb_node
, entry
);
1608 static int dlfb_submit_urb(struct dlfb_data
*dev
, struct urb
*urb
, size_t len
)
1612 BUG_ON(len
> dev
->urbs
.size
);
1614 urb
->transfer_buffer_length
= len
; /* set to actual payload len */
1615 ret
= usb_submit_urb(urb
, GFP_KERNEL
);
1617 dlfb_urb_completion(urb
); /* because no one else will */
1618 atomic_set(&dev
->lost_pixels
, 1);
1619 dl_err("usb_submit_urb error %x\n", ret
);
1624 MODULE_AUTHOR("Roberto De Ioris <roberto@unbit.it>, "
1625 "Jaya Kumar <jayakumar.lkml@gmail.com>, "
1626 "Bernie Thompson <bernie@plugable.com>");
1627 MODULE_DESCRIPTION("DisplayLink kernel framebuffer driver");
1628 MODULE_LICENSE("GPL");