1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20
21#include <linux/module.h>
22#include <linux/kernel.h>
23#include <linux/init.h>
24#include <linux/usb.h>
25#include <linux/uaccess.h>
26#include <linux/mm.h>
27#include <linux/fb.h>
28#include <linux/vmalloc.h>
29#include <linux/slab.h>
30#include <linux/delay.h>
31#include <video/udlfb.h>
32#include "edid.h"
33
34static struct fb_fix_screeninfo dlfb_fix = {
35 .id = "udlfb",
36 .type = FB_TYPE_PACKED_PIXELS,
37 .visual = FB_VISUAL_TRUECOLOR,
38 .xpanstep = 0,
39 .ypanstep = 0,
40 .ywrapstep = 0,
41 .accel = FB_ACCEL_NONE,
42};
43
44static const u32 udlfb_info_flags = FBINFO_DEFAULT | FBINFO_READS_FAST |
45 FBINFO_VIRTFB |
46 FBINFO_HWACCEL_IMAGEBLIT | FBINFO_HWACCEL_FILLRECT |
47 FBINFO_HWACCEL_COPYAREA | FBINFO_MISC_ALWAYS_SETPAR;
48
49
50
51
52
53
54
55static struct usb_device_id id_table[] = {
56 {.idVendor = 0x17e9, .match_flags = USB_DEVICE_ID_MATCH_VENDOR,},
57 {},
58};
59MODULE_DEVICE_TABLE(usb, id_table);
60
61
62static int console;
63static int fb_defio;
64
65
66static void dlfb_urb_completion(struct urb *urb);
67static struct urb *dlfb_get_urb(struct dlfb_data *dev);
68static int dlfb_submit_urb(struct dlfb_data *dev, struct urb * urb, size_t len);
69static int dlfb_alloc_urb_list(struct dlfb_data *dev, int count, size_t size);
70static void dlfb_free_urb_list(struct dlfb_data *dev);
71
72
73
74
75
76static char *dlfb_set_register(char *buf, u8 reg, u8 val)
77{
78 *buf++ = 0xAF;
79 *buf++ = 0x20;
80 *buf++ = reg;
81 *buf++ = val;
82 return buf;
83}
84
85static char *dlfb_vidreg_lock(char *buf)
86{
87 return dlfb_set_register(buf, 0xFF, 0x00);
88}
89
90static char *dlfb_vidreg_unlock(char *buf)
91{
92 return dlfb_set_register(buf, 0xFF, 0xFF);
93}
94
95
96
97
98
99
100
101static char *dlfb_enable_hvsync(char *buf, bool enable)
102{
103 if (enable)
104 return dlfb_set_register(buf, 0x1F, 0x00);
105 else
106 return dlfb_set_register(buf, 0x1F, 0x07);
107}
108
109static char *dlfb_set_color_depth(char *buf, u8 selection)
110{
111 return dlfb_set_register(buf, 0x00, selection);
112}
113
114static char *dlfb_set_base16bpp(char *wrptr, u32 base)
115{
116
117 wrptr = dlfb_set_register(wrptr, 0x20, base >> 16);
118 wrptr = dlfb_set_register(wrptr, 0x21, base >> 8);
119 return dlfb_set_register(wrptr, 0x22, base);
120}
121
122
123
124
125
126static char *dlfb_set_base8bpp(char *wrptr, u32 base)
127{
128 wrptr = dlfb_set_register(wrptr, 0x26, base >> 16);
129 wrptr = dlfb_set_register(wrptr, 0x27, base >> 8);
130 return dlfb_set_register(wrptr, 0x28, base);
131}
132
133static char *dlfb_set_register_16(char *wrptr, u8 reg, u16 value)
134{
135 wrptr = dlfb_set_register(wrptr, reg, value >> 8);
136 return dlfb_set_register(wrptr, reg+1, value);
137}
138
139
140
141
142
143static char *dlfb_set_register_16be(char *wrptr, u8 reg, u16 value)
144{
145 wrptr = dlfb_set_register(wrptr, reg, value);
146 return dlfb_set_register(wrptr, reg+1, value >> 8);
147}
148
149
150
151
152
153
154
155
156
157
158static u16 dlfb_lfsr16(u16 actual_count)
159{
160 u32 lv = 0xFFFF;
161
162 while (actual_count--) {
163 lv = ((lv << 1) |
164 (((lv >> 15) ^ (lv >> 4) ^ (lv >> 2) ^ (lv >> 1)) & 1))
165 & 0xFFFF;
166 }
167
168 return (u16) lv;
169}
170
171
172
173
174
175static char *dlfb_set_register_lfsr16(char *wrptr, u8 reg, u16 value)
176{
177 return dlfb_set_register_16(wrptr, reg, dlfb_lfsr16(value));
178}
179
180
181
182
183
184static char *dlfb_set_vid_cmds(char *wrptr, struct fb_var_screeninfo *var)
185{
186 u16 xds, yds;
187 u16 xde, yde;
188 u16 yec;
189
190
191 xds = var->left_margin + var->hsync_len;
192 wrptr = dlfb_set_register_lfsr16(wrptr, 0x01, xds);
193
194 xde = xds + var->xres;
195 wrptr = dlfb_set_register_lfsr16(wrptr, 0x03, xde);
196
197
198 yds = var->upper_margin + var->vsync_len;
199 wrptr = dlfb_set_register_lfsr16(wrptr, 0x05, yds);
200
201 yde = yds + var->yres;
202 wrptr = dlfb_set_register_lfsr16(wrptr, 0x07, yde);
203
204
205 wrptr = dlfb_set_register_lfsr16(wrptr, 0x09,
206 xde + var->right_margin - 1);
207
208
209 wrptr = dlfb_set_register_lfsr16(wrptr, 0x0B, 1);
210
211
212 wrptr = dlfb_set_register_lfsr16(wrptr, 0x0D, var->hsync_len + 1);
213
214
215 wrptr = dlfb_set_register_16(wrptr, 0x0F, var->xres);
216
217
218 yec = var->yres + var->upper_margin + var->lower_margin +
219 var->vsync_len;
220 wrptr = dlfb_set_register_lfsr16(wrptr, 0x11, yec);
221
222
223 wrptr = dlfb_set_register_lfsr16(wrptr, 0x13, 0);
224
225
226 wrptr = dlfb_set_register_lfsr16(wrptr, 0x15, var->vsync_len);
227
228
229 wrptr = dlfb_set_register_16(wrptr, 0x17, var->yres);
230
231
232 wrptr = dlfb_set_register_16be(wrptr, 0x1B,
233 200*1000*1000/var->pixclock);
234
235 return wrptr;
236}
237
238
239
240
241
242
243static int dlfb_set_video_mode(struct dlfb_data *dev,
244 struct fb_var_screeninfo *var)
245{
246 char *buf;
247 char *wrptr;
248 int retval = 0;
249 int writesize;
250 struct urb *urb;
251
252 if (!atomic_read(&dev->usb_active))
253 return -EPERM;
254
255 urb = dlfb_get_urb(dev);
256 if (!urb)
257 return -ENOMEM;
258
259 buf = (char *) urb->transfer_buffer;
260
261
262
263
264
265
266 wrptr = dlfb_vidreg_lock(buf);
267 wrptr = dlfb_set_color_depth(wrptr, 0x00);
268
269 wrptr = dlfb_set_base16bpp(wrptr, 0);
270
271 wrptr = dlfb_set_base8bpp(wrptr, dev->info->fix.smem_len);
272
273 wrptr = dlfb_set_vid_cmds(wrptr, var);
274 wrptr = dlfb_enable_hvsync(wrptr, true);
275 wrptr = dlfb_vidreg_unlock(wrptr);
276
277 writesize = wrptr - buf;
278
279 retval = dlfb_submit_urb(dev, urb, writesize);
280
281 return retval;
282}
283
284static int dlfb_ops_mmap(struct fb_info *info, struct vm_area_struct *vma)
285{
286 unsigned long start = vma->vm_start;
287 unsigned long size = vma->vm_end - vma->vm_start;
288 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
289 unsigned long page, pos;
290
291 if (offset + size > info->fix.smem_len)
292 return -EINVAL;
293
294 pos = (unsigned long)info->fix.smem_start + offset;
295
296 pr_notice("mmap() framebuffer addr:%lu size:%lu\n",
297 pos, size);
298
299 while (size > 0) {
300 page = vmalloc_to_pfn((void *)pos);
301 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
302 return -EAGAIN;
303
304 start += PAGE_SIZE;
305 pos += PAGE_SIZE;
306 if (size > PAGE_SIZE)
307 size -= PAGE_SIZE;
308 else
309 size = 0;
310 }
311
312 vma->vm_flags |= VM_RESERVED;
313 return 0;
314}
315
316
317
318
319
320
321
322
323static int dlfb_trim_hline(const u8 *bback, const u8 **bfront, int *width_bytes)
324{
325 int j, k;
326 const unsigned long *back = (const unsigned long *) bback;
327 const unsigned long *front = (const unsigned long *) *bfront;
328 const int width = *width_bytes / sizeof(unsigned long);
329 int identical = width;
330 int start = width;
331 int end = width;
332
333 prefetch((void *) front);
334 prefetch((void *) back);
335
336 for (j = 0; j < width; j++) {
337 if (back[j] != front[j]) {
338 start = j;
339 break;
340 }
341 }
342
343 for (k = width - 1; k > j; k--) {
344 if (back[k] != front[k]) {
345 end = k+1;
346 break;
347 }
348 }
349
350 identical = start + (width - end);
351 *bfront = (u8 *) &front[start];
352 *width_bytes = (end - start) * sizeof(unsigned long);
353
354 return identical * sizeof(unsigned long);
355}
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384static void dlfb_compress_hline(
385 const uint16_t **pixel_start_ptr,
386 const uint16_t *const pixel_end,
387 uint32_t *device_address_ptr,
388 uint8_t **command_buffer_ptr,
389 const uint8_t *const cmd_buffer_end)
390{
391 const uint16_t *pixel = *pixel_start_ptr;
392 uint32_t dev_addr = *device_address_ptr;
393 uint8_t *cmd = *command_buffer_ptr;
394 const int bpp = 2;
395
396 while ((pixel_end > pixel) &&
397 (cmd_buffer_end - MIN_RLX_CMD_BYTES > cmd)) {
398 uint8_t *raw_pixels_count_byte = 0;
399 uint8_t *cmd_pixels_count_byte = 0;
400 const uint16_t *raw_pixel_start = 0;
401 const uint16_t *cmd_pixel_start, *cmd_pixel_end = 0;
402
403 prefetchw((void *) cmd);
404
405 *cmd++ = 0xAF;
406 *cmd++ = 0x6B;
407 *cmd++ = (uint8_t) ((dev_addr >> 16) & 0xFF);
408 *cmd++ = (uint8_t) ((dev_addr >> 8) & 0xFF);
409 *cmd++ = (uint8_t) ((dev_addr) & 0xFF);
410
411 cmd_pixels_count_byte = cmd++;
412 cmd_pixel_start = pixel;
413
414 raw_pixels_count_byte = cmd++;
415 raw_pixel_start = pixel;
416
417 cmd_pixel_end = pixel + min(MAX_CMD_PIXELS + 1,
418 min((int)(pixel_end - pixel),
419 (int)(cmd_buffer_end - cmd) / bpp));
420
421 prefetch_range((void *) pixel, (cmd_pixel_end - pixel) * bpp);
422
423 while (pixel < cmd_pixel_end) {
424 const uint16_t * const repeating_pixel = pixel;
425
426 *(uint16_t *)cmd = cpu_to_be16p(pixel);
427 cmd += 2;
428 pixel++;
429
430 if (unlikely((pixel < cmd_pixel_end) &&
431 (*pixel == *repeating_pixel))) {
432
433 *raw_pixels_count_byte = ((repeating_pixel -
434 raw_pixel_start) + 1) & 0xFF;
435
436 while ((pixel < cmd_pixel_end)
437 && (*pixel == *repeating_pixel)) {
438 pixel++;
439 }
440
441
442 *cmd++ = ((pixel - repeating_pixel) - 1) & 0xFF;
443
444
445 raw_pixel_start = pixel;
446 raw_pixels_count_byte = cmd++;
447 }
448 }
449
450 if (pixel > raw_pixel_start) {
451
452 *raw_pixels_count_byte = (pixel-raw_pixel_start) & 0xFF;
453 }
454
455 *cmd_pixels_count_byte = (pixel - cmd_pixel_start) & 0xFF;
456 dev_addr += (pixel - cmd_pixel_start) * bpp;
457 }
458
459 if (cmd_buffer_end <= MIN_RLX_CMD_BYTES + cmd) {
460
461 if (cmd_buffer_end > cmd)
462 memset(cmd, 0xAF, cmd_buffer_end - cmd);
463 cmd = (uint8_t *) cmd_buffer_end;
464 }
465
466 *command_buffer_ptr = cmd;
467 *pixel_start_ptr = pixel;
468 *device_address_ptr = dev_addr;
469
470 return;
471}
472
473
474
475
476
477
478
479static int dlfb_render_hline(struct dlfb_data *dev, struct urb **urb_ptr,
480 const char *front, char **urb_buf_ptr,
481 u32 byte_offset, u32 byte_width,
482 int *ident_ptr, int *sent_ptr)
483{
484 const u8 *line_start, *line_end, *next_pixel;
485 u32 dev_addr = dev->base16 + byte_offset;
486 struct urb *urb = *urb_ptr;
487 u8 *cmd = *urb_buf_ptr;
488 u8 *cmd_end = (u8 *) urb->transfer_buffer + urb->transfer_buffer_length;
489
490 line_start = (u8 *) (front + byte_offset);
491 next_pixel = line_start;
492 line_end = next_pixel + byte_width;
493
494 if (dev->backing_buffer) {
495 int offset;
496 const u8 *back_start = (u8 *) (dev->backing_buffer
497 + byte_offset);
498
499 *ident_ptr += dlfb_trim_hline(back_start, &next_pixel,
500 &byte_width);
501
502 offset = next_pixel - line_start;
503 line_end = next_pixel + byte_width;
504 dev_addr += offset;
505 back_start += offset;
506 line_start += offset;
507
508 memcpy((char *)back_start, (char *) line_start,
509 byte_width);
510 }
511
512 while (next_pixel < line_end) {
513
514 dlfb_compress_hline((const uint16_t **) &next_pixel,
515 (const uint16_t *) line_end, &dev_addr,
516 (u8 **) &cmd, (u8 *) cmd_end);
517
518 if (cmd >= cmd_end) {
519 int len = cmd - (u8 *) urb->transfer_buffer;
520 if (dlfb_submit_urb(dev, urb, len))
521 return 1;
522 *sent_ptr += len;
523 urb = dlfb_get_urb(dev);
524 if (!urb)
525 return 1;
526 *urb_ptr = urb;
527 cmd = urb->transfer_buffer;
528 cmd_end = &cmd[urb->transfer_buffer_length];
529 }
530 }
531
532 *urb_buf_ptr = cmd;
533
534 return 0;
535}
536
537int dlfb_handle_damage(struct dlfb_data *dev, int x, int y,
538 int width, int height, char *data)
539{
540 int i, ret;
541 char *cmd;
542 cycles_t start_cycles, end_cycles;
543 int bytes_sent = 0;
544 int bytes_identical = 0;
545 struct urb *urb;
546 int aligned_x;
547
548 start_cycles = get_cycles();
549
550 aligned_x = DL_ALIGN_DOWN(x, sizeof(unsigned long));
551 width = DL_ALIGN_UP(width + (x-aligned_x), sizeof(unsigned long));
552 x = aligned_x;
553
554 if ((width <= 0) ||
555 (x + width > dev->info->var.xres) ||
556 (y + height > dev->info->var.yres))
557 return -EINVAL;
558
559 if (!atomic_read(&dev->usb_active))
560 return 0;
561
562 urb = dlfb_get_urb(dev);
563 if (!urb)
564 return 0;
565 cmd = urb->transfer_buffer;
566
567 for (i = y; i < y + height ; i++) {
568 const int line_offset = dev->info->fix.line_length * i;
569 const int byte_offset = line_offset + (x * BPP);
570
571 if (dlfb_render_hline(dev, &urb,
572 (char *) dev->info->fix.smem_start,
573 &cmd, byte_offset, width * BPP,
574 &bytes_identical, &bytes_sent))
575 goto error;
576 }
577
578 if (cmd > (char *) urb->transfer_buffer) {
579
580 int len = cmd - (char *) urb->transfer_buffer;
581 ret = dlfb_submit_urb(dev, urb, len);
582 bytes_sent += len;
583 } else
584 dlfb_urb_completion(urb);
585
586error:
587 atomic_add(bytes_sent, &dev->bytes_sent);
588 atomic_add(bytes_identical, &dev->bytes_identical);
589 atomic_add(width*height*2, &dev->bytes_rendered);
590 end_cycles = get_cycles();
591 atomic_add(((unsigned int) ((end_cycles - start_cycles)
592 >> 10)),
593 &dev->cpu_kcycles_used);
594
595 return 0;
596}
597
598
599
600
601
602
603
604static ssize_t dlfb_ops_write(struct fb_info *info, const char __user *buf,
605 size_t count, loff_t *ppos)
606{
607 ssize_t result;
608 struct dlfb_data *dev = info->par;
609 u32 offset = (u32) *ppos;
610
611 result = fb_sys_write(info, buf, count, ppos);
612
613 if (result > 0) {
614 int start = max((int)(offset / info->fix.line_length) - 1, 0);
615 int lines = min((u32)((result / info->fix.line_length) + 1),
616 (u32)info->var.yres);
617
618 dlfb_handle_damage(dev, 0, start, info->var.xres,
619 lines, info->screen_base);
620 }
621
622 return result;
623}
624
625
626static void dlfb_ops_copyarea(struct fb_info *info,
627 const struct fb_copyarea *area)
628{
629
630 struct dlfb_data *dev = info->par;
631
632 sys_copyarea(info, area);
633
634 dlfb_handle_damage(dev, area->dx, area->dy,
635 area->width, area->height, info->screen_base);
636}
637
638static void dlfb_ops_imageblit(struct fb_info *info,
639 const struct fb_image *image)
640{
641 struct dlfb_data *dev = info->par;
642
643 sys_imageblit(info, image);
644
645 dlfb_handle_damage(dev, image->dx, image->dy,
646 image->width, image->height, info->screen_base);
647}
648
649static void dlfb_ops_fillrect(struct fb_info *info,
650 const struct fb_fillrect *rect)
651{
652 struct dlfb_data *dev = info->par;
653
654 sys_fillrect(info, rect);
655
656 dlfb_handle_damage(dev, rect->dx, rect->dy, rect->width,
657 rect->height, info->screen_base);
658}
659
660
661
662
663
664
665
666static void dlfb_dpy_deferred_io(struct fb_info *info,
667 struct list_head *pagelist)
668{
669 struct page *cur;
670 struct fb_deferred_io *fbdefio = info->fbdefio;
671 struct dlfb_data *dev = info->par;
672 struct urb *urb;
673 char *cmd;
674 cycles_t start_cycles, end_cycles;
675 int bytes_sent = 0;
676 int bytes_identical = 0;
677 int bytes_rendered = 0;
678
679 if (!fb_defio)
680 return;
681
682 if (!atomic_read(&dev->usb_active))
683 return;
684
685 start_cycles = get_cycles();
686
687 urb = dlfb_get_urb(dev);
688 if (!urb)
689 return;
690
691 cmd = urb->transfer_buffer;
692
693
694 list_for_each_entry(cur, &fbdefio->pagelist, lru) {
695
696 if (dlfb_render_hline(dev, &urb, (char *) info->fix.smem_start,
697 &cmd, cur->index << PAGE_SHIFT,
698 PAGE_SIZE, &bytes_identical, &bytes_sent))
699 goto error;
700 bytes_rendered += PAGE_SIZE;
701 }
702
703 if (cmd > (char *) urb->transfer_buffer) {
704
705 int len = cmd - (char *) urb->transfer_buffer;
706 dlfb_submit_urb(dev, urb, len);
707 bytes_sent += len;
708 } else
709 dlfb_urb_completion(urb);
710
711error:
712 atomic_add(bytes_sent, &dev->bytes_sent);
713 atomic_add(bytes_identical, &dev->bytes_identical);
714 atomic_add(bytes_rendered, &dev->bytes_rendered);
715 end_cycles = get_cycles();
716 atomic_add(((unsigned int) ((end_cycles - start_cycles)
717 >> 10)),
718 &dev->cpu_kcycles_used);
719}
720
721static int dlfb_get_edid(struct dlfb_data *dev, char *edid, int len)
722{
723 int i;
724 int ret;
725 char *rbuf;
726
727 rbuf = kmalloc(2, GFP_KERNEL);
728 if (!rbuf)
729 return 0;
730
731 for (i = 0; i < len; i++) {
732 ret = usb_control_msg(dev->udev,
733 usb_rcvctrlpipe(dev->udev, 0), (0x02),
734 (0x80 | (0x02 << 5)), i << 8, 0xA1, rbuf, 2,
735 HZ);
736 if (ret < 1) {
737 pr_err("Read EDID byte %d failed err %x\n", i, ret);
738 i--;
739 break;
740 }
741 edid[i] = rbuf[1];
742 }
743
744 kfree(rbuf);
745
746 return i;
747}
748
749static int dlfb_ops_ioctl(struct fb_info *info, unsigned int cmd,
750 unsigned long arg)
751{
752
753 struct dlfb_data *dev = info->par;
754 struct dloarea *area = NULL;
755
756 if (!atomic_read(&dev->usb_active))
757 return 0;
758
759
760 if (cmd == DLFB_IOCTL_RETURN_EDID) {
761 char *edid = (char *)arg;
762 if (copy_to_user(edid, dev->edid, dev->edid_size))
763 return -EFAULT;
764 return 0;
765 }
766
767
768 if (cmd == DLFB_IOCTL_REPORT_DAMAGE) {
769
770
771
772
773
774
775
776
777 if (info->fbdefio)
778 info->fbdefio->delay = DL_DEFIO_WRITE_DISABLE;
779
780 area = (struct dloarea *)arg;
781
782 if (area->x < 0)
783 area->x = 0;
784
785 if (area->x > info->var.xres)
786 area->x = info->var.xres;
787
788 if (area->y < 0)
789 area->y = 0;
790
791 if (area->y > info->var.yres)
792 area->y = info->var.yres;
793
794 dlfb_handle_damage(dev, area->x, area->y, area->w, area->h,
795 info->screen_base);
796 }
797
798 return 0;
799}
800
801
802static int
803dlfb_ops_setcolreg(unsigned regno, unsigned red, unsigned green,
804 unsigned blue, unsigned transp, struct fb_info *info)
805{
806 int err = 0;
807
808 if (regno >= info->cmap.len)
809 return 1;
810
811 if (regno < 16) {
812 if (info->var.red.offset == 10) {
813
814 ((u32 *) (info->pseudo_palette))[regno] =
815 ((red & 0xf800) >> 1) |
816 ((green & 0xf800) >> 6) | ((blue & 0xf800) >> 11);
817 } else {
818
819 ((u32 *) (info->pseudo_palette))[regno] =
820 ((red & 0xf800)) |
821 ((green & 0xfc00) >> 5) | ((blue & 0xf800) >> 11);
822 }
823 }
824
825 return err;
826}
827
828
829
830
831
832
833static int dlfb_ops_open(struct fb_info *info, int user)
834{
835 struct dlfb_data *dev = info->par;
836
837
838
839
840
841
842 if ((user == 0) & (!console))
843 return -EBUSY;
844
845
846 if (dev->virtualized)
847 return -ENODEV;
848
849 dev->fb_count++;
850
851 kref_get(&dev->kref);
852
853 if (fb_defio && (info->fbdefio == NULL)) {
854
855
856 struct fb_deferred_io *fbdefio;
857
858 fbdefio = kmalloc(sizeof(struct fb_deferred_io), GFP_KERNEL);
859
860 if (fbdefio) {
861 fbdefio->delay = DL_DEFIO_WRITE_DELAY;
862 fbdefio->deferred_io = dlfb_dpy_deferred_io;
863 }
864
865 info->fbdefio = fbdefio;
866 fb_deferred_io_init(info);
867 }
868
869 pr_notice("open /dev/fb%d user=%d fb_info=%p count=%d\n",
870 info->node, user, info, dev->fb_count);
871
872 return 0;
873}
874
875
876
877
878
879
880static void dlfb_free(struct kref *kref)
881{
882 struct dlfb_data *dev = container_of(kref, struct dlfb_data, kref);
883
884
885 if (dev->urbs.count > 0)
886 dlfb_free_urb_list(dev);
887
888 if (dev->backing_buffer)
889 vfree(dev->backing_buffer);
890
891 kfree(dev->edid);
892
893 pr_warn("freeing dlfb_data %p\n", dev);
894
895 kfree(dev);
896}
897
898static void dlfb_release_urb_work(struct work_struct *work)
899{
900 struct urb_node *unode = container_of(work, struct urb_node,
901 release_urb_work.work);
902
903 up(&unode->dev->urbs.limit_sem);
904}
905
906static void dlfb_free_framebuffer_work(struct work_struct *work)
907{
908 struct dlfb_data *dev = container_of(work, struct dlfb_data,
909 free_framebuffer_work.work);
910 struct fb_info *info = dev->info;
911 int node = info->node;
912
913 unregister_framebuffer(info);
914
915 if (info->cmap.len != 0)
916 fb_dealloc_cmap(&info->cmap);
917 if (info->monspecs.modedb)
918 fb_destroy_modedb(info->monspecs.modedb);
919 if (info->screen_base)
920 vfree(info->screen_base);
921
922 fb_destroy_modelist(&info->modelist);
923
924 dev->info = 0;
925
926
927 framebuffer_release(info);
928
929 pr_warn("fb_info for /dev/fb%d has been freed\n", node);
930
931
932 kref_put(&dev->kref, dlfb_free);
933}
934
935
936
937
938static int dlfb_ops_release(struct fb_info *info, int user)
939{
940 struct dlfb_data *dev = info->par;
941
942 dev->fb_count--;
943
944
945 if (dev->virtualized && (dev->fb_count == 0))
946 schedule_delayed_work(&dev->free_framebuffer_work, HZ);
947
948 if ((dev->fb_count == 0) && (info->fbdefio)) {
949 fb_deferred_io_cleanup(info);
950 kfree(info->fbdefio);
951 info->fbdefio = NULL;
952 info->fbops->fb_mmap = dlfb_ops_mmap;
953 }
954
955 pr_warn("released /dev/fb%d user=%d count=%d\n",
956 info->node, user, dev->fb_count);
957
958 kref_put(&dev->kref, dlfb_free);
959
960 return 0;
961}
962
963
964
965
966
967static int dlfb_is_valid_mode(struct fb_videomode *mode,
968 struct fb_info *info)
969{
970 struct dlfb_data *dev = info->par;
971
972 if (mode->xres * mode->yres > dev->sku_pixel_limit) {
973 pr_warn("%dx%d beyond chip capabilities\n",
974 mode->xres, mode->yres);
975 return 0;
976 }
977
978 pr_info("%dx%d valid mode\n", mode->xres, mode->yres);
979
980 return 1;
981}
982
983static void dlfb_var_color_format(struct fb_var_screeninfo *var)
984{
985 const struct fb_bitfield red = { 11, 5, 0 };
986 const struct fb_bitfield green = { 5, 6, 0 };
987 const struct fb_bitfield blue = { 0, 5, 0 };
988
989 var->bits_per_pixel = 16;
990 var->red = red;
991 var->green = green;
992 var->blue = blue;
993}
994
995static int dlfb_ops_check_var(struct fb_var_screeninfo *var,
996 struct fb_info *info)
997{
998 struct fb_videomode mode;
999
1000
1001 if ((var->xres * var->yres * 2) > info->fix.smem_len)
1002 return -EINVAL;
1003
1004
1005 dlfb_var_color_format(var);
1006
1007 fb_var_to_videomode(&mode, var);
1008
1009 if (!dlfb_is_valid_mode(&mode, info))
1010 return -EINVAL;
1011
1012 return 0;
1013}
1014
1015static int dlfb_ops_set_par(struct fb_info *info)
1016{
1017 struct dlfb_data *dev = info->par;
1018 int result;
1019 u16 *pix_framebuffer;
1020 int i;
1021
1022 pr_notice("set_par mode %dx%d\n", info->var.xres, info->var.yres);
1023
1024 result = dlfb_set_video_mode(dev, &info->var);
1025
1026 if ((result == 0) && (dev->fb_count == 0)) {
1027
1028
1029
1030 pix_framebuffer = (u16 *) info->screen_base;
1031 for (i = 0; i < info->fix.smem_len / 2; i++)
1032 pix_framebuffer[i] = 0x37e6;
1033
1034 dlfb_handle_damage(dev, 0, 0, info->var.xres, info->var.yres,
1035 info->screen_base);
1036 }
1037
1038 return result;
1039}
1040
1041
1042
1043
1044static int dlfb_ops_blank(int blank_mode, struct fb_info *info)
1045{
1046 struct dlfb_data *dev = info->par;
1047
1048 if (blank_mode != FB_BLANK_UNBLANK) {
1049 char *bufptr;
1050 struct urb *urb;
1051
1052 urb = dlfb_get_urb(dev);
1053 if (!urb)
1054 return 0;
1055
1056 bufptr = (char *) urb->transfer_buffer;
1057 bufptr = dlfb_vidreg_lock(bufptr);
1058 bufptr = dlfb_enable_hvsync(bufptr, false);
1059 bufptr = dlfb_vidreg_unlock(bufptr);
1060
1061 dlfb_submit_urb(dev, urb, bufptr -
1062 (char *) urb->transfer_buffer);
1063 } else {
1064 dlfb_set_video_mode(dev, &info->var);
1065 }
1066
1067 return 0;
1068}
1069
1070static struct fb_ops dlfb_ops = {
1071 .owner = THIS_MODULE,
1072 .fb_read = fb_sys_read,
1073 .fb_write = dlfb_ops_write,
1074 .fb_setcolreg = dlfb_ops_setcolreg,
1075 .fb_fillrect = dlfb_ops_fillrect,
1076 .fb_copyarea = dlfb_ops_copyarea,
1077 .fb_imageblit = dlfb_ops_imageblit,
1078 .fb_mmap = dlfb_ops_mmap,
1079 .fb_ioctl = dlfb_ops_ioctl,
1080 .fb_open = dlfb_ops_open,
1081 .fb_release = dlfb_ops_release,
1082 .fb_blank = dlfb_ops_blank,
1083 .fb_check_var = dlfb_ops_check_var,
1084 .fb_set_par = dlfb_ops_set_par,
1085};
1086
1087
1088
1089
1090
1091
1092static int dlfb_realloc_framebuffer(struct dlfb_data *dev, struct fb_info *info)
1093{
1094 int retval = -ENOMEM;
1095 int old_len = info->fix.smem_len;
1096 int new_len;
1097 unsigned char *old_fb = info->screen_base;
1098 unsigned char *new_fb;
1099 unsigned char *new_back;
1100
1101 pr_warn("Reallocating framebuffer. Addresses will change!\n");
1102
1103 new_len = info->fix.line_length * info->var.yres;
1104
1105 if (PAGE_ALIGN(new_len) > old_len) {
1106
1107
1108
1109 new_fb = vmalloc(new_len);
1110 if (!new_fb) {
1111 pr_err("Virtual framebuffer alloc failed\n");
1112 goto error;
1113 }
1114
1115 if (info->screen_base) {
1116 memcpy(new_fb, old_fb, old_len);
1117 vfree(info->screen_base);
1118 }
1119
1120 info->screen_base = new_fb;
1121 info->fix.smem_len = PAGE_ALIGN(new_len);
1122 info->fix.smem_start = (unsigned long) new_fb;
1123 info->flags = udlfb_info_flags;
1124
1125
1126
1127
1128
1129
1130
1131 new_back = vzalloc(new_len);
1132 if (!new_back)
1133 pr_info("No shadow/backing buffer allocated\n");
1134 else {
1135 if (dev->backing_buffer)
1136 vfree(dev->backing_buffer);
1137 dev->backing_buffer = new_back;
1138 }
1139 }
1140
1141 retval = 0;
1142
1143error:
1144 return retval;
1145}
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161static int dlfb_setup_modes(struct dlfb_data *dev,
1162 struct fb_info *info,
1163 char *default_edid, size_t default_edid_size)
1164{
1165 int i;
1166 const struct fb_videomode *default_vmode = NULL;
1167 int result = 0;
1168 char *edid;
1169 int tries = 3;
1170
1171 if (info->dev)
1172 mutex_lock(&info->lock);
1173
1174 edid = kmalloc(EDID_LENGTH, GFP_KERNEL);
1175 if (!edid) {
1176 result = -ENOMEM;
1177 goto error;
1178 }
1179
1180 fb_destroy_modelist(&info->modelist);
1181 memset(&info->monspecs, 0, sizeof(info->monspecs));
1182
1183
1184
1185
1186
1187
1188 while (tries--) {
1189
1190 i = dlfb_get_edid(dev, edid, EDID_LENGTH);
1191
1192 if (i >= EDID_LENGTH)
1193 fb_edid_to_monspecs(edid, &info->monspecs);
1194
1195 if (info->monspecs.modedb_len > 0) {
1196 dev->edid = edid;
1197 dev->edid_size = i;
1198 break;
1199 }
1200 }
1201
1202
1203 if (info->monspecs.modedb_len == 0) {
1204
1205 pr_err("Unable to get valid EDID from device/display\n");
1206
1207 if (dev->edid) {
1208 fb_edid_to_monspecs(dev->edid, &info->monspecs);
1209 if (info->monspecs.modedb_len > 0)
1210 pr_err("Using previously queried EDID\n");
1211 }
1212 }
1213
1214
1215 if (info->monspecs.modedb_len == 0) {
1216 if (default_edid_size >= EDID_LENGTH) {
1217 fb_edid_to_monspecs(default_edid, &info->monspecs);
1218 if (info->monspecs.modedb_len > 0) {
1219 memcpy(edid, default_edid, default_edid_size);
1220 dev->edid = edid;
1221 dev->edid_size = default_edid_size;
1222 pr_err("Using default/backup EDID\n");
1223 }
1224 }
1225 }
1226
1227
1228 if (info->monspecs.modedb_len > 0) {
1229
1230 for (i = 0; i < info->monspecs.modedb_len; i++) {
1231 if (dlfb_is_valid_mode(&info->monspecs.modedb[i], info))
1232 fb_add_videomode(&info->monspecs.modedb[i],
1233 &info->modelist);
1234 else
1235 info->monspecs.misc &= ~FB_MISC_1ST_DETAIL;
1236 }
1237
1238 default_vmode = fb_find_best_display(&info->monspecs,
1239 &info->modelist);
1240 }
1241
1242
1243 if (default_vmode == NULL) {
1244
1245 struct fb_videomode fb_vmode = {0};
1246
1247
1248
1249
1250
1251
1252
1253 for (i = 0; i < VESA_MODEDB_SIZE; i++) {
1254 if (dlfb_is_valid_mode((struct fb_videomode *)
1255 &vesa_modes[i], info))
1256 fb_add_videomode(&vesa_modes[i],
1257 &info->modelist);
1258 }
1259
1260
1261
1262
1263
1264 fb_vmode.xres = 800;
1265 fb_vmode.yres = 600;
1266 fb_vmode.refresh = 60;
1267 default_vmode = fb_find_nearest_mode(&fb_vmode,
1268 &info->modelist);
1269 }
1270
1271
1272 if ((default_vmode != NULL) && (dev->fb_count == 0)) {
1273
1274 fb_videomode_to_var(&info->var, default_vmode);
1275 dlfb_var_color_format(&info->var);
1276
1277
1278
1279
1280 memcpy(&info->fix, &dlfb_fix, sizeof(dlfb_fix));
1281 info->fix.line_length = info->var.xres *
1282 (info->var.bits_per_pixel / 8);
1283
1284 result = dlfb_realloc_framebuffer(dev, info);
1285
1286 } else
1287 result = -EINVAL;
1288
1289error:
1290 if (edid && (dev->edid != edid))
1291 kfree(edid);
1292
1293 if (info->dev)
1294 mutex_unlock(&info->lock);
1295
1296 return result;
1297}
1298
1299static ssize_t metrics_bytes_rendered_show(struct device *fbdev,
1300 struct device_attribute *a, char *buf) {
1301 struct fb_info *fb_info = dev_get_drvdata(fbdev);
1302 struct dlfb_data *dev = fb_info->par;
1303 return snprintf(buf, PAGE_SIZE, "%u\n",
1304 atomic_read(&dev->bytes_rendered));
1305}
1306
1307static ssize_t metrics_bytes_identical_show(struct device *fbdev,
1308 struct device_attribute *a, char *buf) {
1309 struct fb_info *fb_info = dev_get_drvdata(fbdev);
1310 struct dlfb_data *dev = fb_info->par;
1311 return snprintf(buf, PAGE_SIZE, "%u\n",
1312 atomic_read(&dev->bytes_identical));
1313}
1314
1315static ssize_t metrics_bytes_sent_show(struct device *fbdev,
1316 struct device_attribute *a, char *buf) {
1317 struct fb_info *fb_info = dev_get_drvdata(fbdev);
1318 struct dlfb_data *dev = fb_info->par;
1319 return snprintf(buf, PAGE_SIZE, "%u\n",
1320 atomic_read(&dev->bytes_sent));
1321}
1322
1323static ssize_t metrics_cpu_kcycles_used_show(struct device *fbdev,
1324 struct device_attribute *a, char *buf) {
1325 struct fb_info *fb_info = dev_get_drvdata(fbdev);
1326 struct dlfb_data *dev = fb_info->par;
1327 return snprintf(buf, PAGE_SIZE, "%u\n",
1328 atomic_read(&dev->cpu_kcycles_used));
1329}
1330
1331static ssize_t edid_show(
1332 struct file *filp,
1333 struct kobject *kobj, struct bin_attribute *a,
1334 char *buf, loff_t off, size_t count) {
1335 struct device *fbdev = container_of(kobj, struct device, kobj);
1336 struct fb_info *fb_info = dev_get_drvdata(fbdev);
1337 struct dlfb_data *dev = fb_info->par;
1338
1339 if (dev->edid == NULL)
1340 return 0;
1341
1342 if ((off >= dev->edid_size) || (count > dev->edid_size))
1343 return 0;
1344
1345 if (off + count > dev->edid_size)
1346 count = dev->edid_size - off;
1347
1348 pr_info("sysfs edid copy %p to %p, %d bytes\n",
1349 dev->edid, buf, (int) count);
1350
1351 memcpy(buf, dev->edid, count);
1352
1353 return count;
1354}
1355
1356static ssize_t edid_store(
1357 struct file *filp,
1358 struct kobject *kobj, struct bin_attribute *a,
1359 char *src, loff_t src_off, size_t src_size) {
1360 struct device *fbdev = container_of(kobj, struct device, kobj);
1361 struct fb_info *fb_info = dev_get_drvdata(fbdev);
1362 struct dlfb_data *dev = fb_info->par;
1363
1364
1365 if ((src_size != EDID_LENGTH) || (src_off != 0))
1366 return 0;
1367
1368 dlfb_setup_modes(dev, fb_info, src, src_size);
1369
1370 if (dev->edid && (memcmp(src, dev->edid, src_size) == 0)) {
1371 pr_info("sysfs written EDID is new default\n");
1372 dlfb_ops_set_par(fb_info);
1373 return src_size;
1374 } else
1375 return 0;
1376}
1377
1378static ssize_t metrics_reset_store(struct device *fbdev,
1379 struct device_attribute *attr,
1380 const char *buf, size_t count)
1381{
1382 struct fb_info *fb_info = dev_get_drvdata(fbdev);
1383 struct dlfb_data *dev = fb_info->par;
1384
1385 atomic_set(&dev->bytes_rendered, 0);
1386 atomic_set(&dev->bytes_identical, 0);
1387 atomic_set(&dev->bytes_sent, 0);
1388 atomic_set(&dev->cpu_kcycles_used, 0);
1389
1390 return count;
1391}
1392
1393static struct bin_attribute edid_attr = {
1394 .attr.name = "edid",
1395 .attr.mode = 0666,
1396 .size = EDID_LENGTH,
1397 .read = edid_show,
1398 .write = edid_store
1399};
1400
1401static struct device_attribute fb_device_attrs[] = {
1402 __ATTR_RO(metrics_bytes_rendered),
1403 __ATTR_RO(metrics_bytes_identical),
1404 __ATTR_RO(metrics_bytes_sent),
1405 __ATTR_RO(metrics_cpu_kcycles_used),
1406 __ATTR(metrics_reset, S_IWUSR, NULL, metrics_reset_store),
1407};
1408
1409
1410
1411
1412static int dlfb_select_std_channel(struct dlfb_data *dev)
1413{
1414 int ret;
1415 u8 set_def_chn[] = { 0x57, 0xCD, 0xDC, 0xA7,
1416 0x1C, 0x88, 0x5E, 0x15,
1417 0x60, 0xFE, 0xC6, 0x97,
1418 0x16, 0x3D, 0x47, 0xF2 };
1419
1420 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
1421 NR_USB_REQUEST_CHANNEL,
1422 (USB_DIR_OUT | USB_TYPE_VENDOR), 0, 0,
1423 set_def_chn, sizeof(set_def_chn), USB_CTRL_SET_TIMEOUT);
1424 return ret;
1425}
1426
1427static int dlfb_parse_vendor_descriptor(struct dlfb_data *dev,
1428 struct usb_device *usbdev)
1429{
1430 char *desc;
1431 char *buf;
1432 char *desc_end;
1433
1434 u8 total_len = 0;
1435
1436 buf = kzalloc(MAX_VENDOR_DESCRIPTOR_SIZE, GFP_KERNEL);
1437 if (!buf)
1438 return false;
1439 desc = buf;
1440
1441 total_len = usb_get_descriptor(usbdev, 0x5f,
1442 0, desc, MAX_VENDOR_DESCRIPTOR_SIZE);
1443 if (total_len > 5) {
1444 pr_info("vendor descriptor length:%x data:%02x %02x %02x %02x" \
1445 "%02x %02x %02x %02x %02x %02x %02x\n",
1446 total_len, desc[0],
1447 desc[1], desc[2], desc[3], desc[4], desc[5], desc[6],
1448 desc[7], desc[8], desc[9], desc[10]);
1449
1450 if ((desc[0] != total_len) ||
1451 (desc[1] != 0x5f) ||
1452 (desc[2] != 0x01) ||
1453 (desc[3] != 0x00) ||
1454 (desc[4] != total_len - 2))
1455 goto unrecognized;
1456
1457 desc_end = desc + total_len;
1458 desc += 5;
1459
1460 while (desc < desc_end) {
1461 u8 length;
1462 u16 key;
1463
1464 key = *((u16 *) desc);
1465 desc += sizeof(u16);
1466 length = *desc;
1467 desc++;
1468
1469 switch (key) {
1470 case 0x0200: {
1471 u32 max_area;
1472 max_area = le32_to_cpu(*((u32 *)desc));
1473 pr_warn("DL chip limited to %d pixel modes\n",
1474 max_area);
1475 dev->sku_pixel_limit = max_area;
1476 break;
1477 }
1478 default:
1479 break;
1480 }
1481 desc += length;
1482 }
1483 }
1484
1485 goto success;
1486
1487unrecognized:
1488
1489 pr_err("Unrecognized vendor firmware descriptor\n");
1490
1491success:
1492 kfree(buf);
1493 return true;
1494}
1495static int dlfb_usb_probe(struct usb_interface *interface,
1496 const struct usb_device_id *id)
1497{
1498 struct usb_device *usbdev;
1499 struct dlfb_data *dev = 0;
1500 struct fb_info *info = 0;
1501 int retval = -ENOMEM;
1502 int i;
1503
1504
1505
1506 usbdev = interface_to_usbdev(interface);
1507
1508 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1509 if (dev == NULL) {
1510 err("dlfb_usb_probe: failed alloc of dev struct\n");
1511 goto error;
1512 }
1513
1514
1515 kref_init(&dev->kref);
1516 kref_get(&dev->kref);
1517
1518 dev->udev = usbdev;
1519 dev->gdev = &usbdev->dev;
1520 usb_set_intfdata(interface, dev);
1521
1522 pr_info("%s %s - serial #%s\n",
1523 usbdev->manufacturer, usbdev->product, usbdev->serial);
1524 pr_info("vid_%04x&pid_%04x&rev_%04x driver's dlfb_data struct at %p\n",
1525 usbdev->descriptor.idVendor, usbdev->descriptor.idProduct,
1526 usbdev->descriptor.bcdDevice, dev);
1527 pr_info("console enable=%d\n", console);
1528 pr_info("fb_defio enable=%d\n", fb_defio);
1529
1530 dev->sku_pixel_limit = 2048 * 1152;
1531
1532 if (!dlfb_parse_vendor_descriptor(dev, usbdev)) {
1533 pr_err("firmware not recognized. Assume incompatible device\n");
1534 goto error;
1535 }
1536
1537 if (!dlfb_alloc_urb_list(dev, WRITES_IN_FLIGHT, MAX_TRANSFER)) {
1538 retval = -ENOMEM;
1539 pr_err("dlfb_alloc_urb_list failed\n");
1540 goto error;
1541 }
1542
1543
1544
1545
1546 info = framebuffer_alloc(0, &usbdev->dev);
1547 if (!info) {
1548 retval = -ENOMEM;
1549 pr_err("framebuffer_alloc failed\n");
1550 goto error;
1551 }
1552
1553 dev->info = info;
1554 info->par = dev;
1555 info->pseudo_palette = dev->pseudo_palette;
1556 info->fbops = &dlfb_ops;
1557
1558 retval = fb_alloc_cmap(&info->cmap, 256, 0);
1559 if (retval < 0) {
1560 pr_err("fb_alloc_cmap failed %x\n", retval);
1561 goto error;
1562 }
1563
1564 INIT_DELAYED_WORK(&dev->free_framebuffer_work,
1565 dlfb_free_framebuffer_work);
1566
1567 INIT_LIST_HEAD(&info->modelist);
1568
1569 retval = dlfb_setup_modes(dev, info, NULL, 0);
1570 if (retval != 0) {
1571 pr_err("unable to find common mode for display and adapter\n");
1572 goto error;
1573 }
1574
1575
1576
1577 atomic_set(&dev->usb_active, 1);
1578 dlfb_select_std_channel(dev);
1579
1580 dlfb_ops_check_var(&info->var, info);
1581 dlfb_ops_set_par(info);
1582
1583 retval = register_framebuffer(info);
1584 if (retval < 0) {
1585 pr_err("register_framebuffer failed %d\n", retval);
1586 goto error;
1587 }
1588
1589 for (i = 0; i < ARRAY_SIZE(fb_device_attrs); i++)
1590 device_create_file(info->dev, &fb_device_attrs[i]);
1591
1592 device_create_bin_file(info->dev, &edid_attr);
1593
1594 pr_info("DisplayLink USB device /dev/fb%d attached. %dx%d resolution."
1595 " Using %dK framebuffer memory\n", info->node,
1596 info->var.xres, info->var.yres,
1597 ((dev->backing_buffer) ?
1598 info->fix.smem_len * 2 : info->fix.smem_len) >> 10);
1599 return 0;
1600
1601error:
1602 if (dev) {
1603
1604 if (info) {
1605 if (info->cmap.len != 0)
1606 fb_dealloc_cmap(&info->cmap);
1607 if (info->monspecs.modedb)
1608 fb_destroy_modedb(info->monspecs.modedb);
1609 if (info->screen_base)
1610 vfree(info->screen_base);
1611
1612 fb_destroy_modelist(&info->modelist);
1613
1614 framebuffer_release(info);
1615 }
1616
1617 if (dev->backing_buffer)
1618 vfree(dev->backing_buffer);
1619
1620 kref_put(&dev->kref, dlfb_free);
1621 kref_put(&dev->kref, dlfb_free);
1622
1623
1624 }
1625
1626 return retval;
1627}
1628
1629static void dlfb_usb_disconnect(struct usb_interface *interface)
1630{
1631 struct dlfb_data *dev;
1632 struct fb_info *info;
1633 int i;
1634
1635 dev = usb_get_intfdata(interface);
1636 info = dev->info;
1637
1638 pr_info("USB disconnect starting\n");
1639
1640
1641 dev->virtualized = true;
1642
1643
1644 atomic_set(&dev->usb_active, 0);
1645
1646
1647 for (i = 0; i < ARRAY_SIZE(fb_device_attrs); i++)
1648 device_remove_file(info->dev, &fb_device_attrs[i]);
1649 device_remove_bin_file(info->dev, &edid_attr);
1650
1651 usb_set_intfdata(interface, NULL);
1652
1653
1654 if (dev->fb_count == 0)
1655 schedule_delayed_work(&dev->free_framebuffer_work, 0);
1656
1657
1658 kref_put(&dev->kref, dlfb_free);
1659
1660
1661
1662 return;
1663}
1664
1665static struct usb_driver dlfb_driver = {
1666 .name = "udlfb",
1667 .probe = dlfb_usb_probe,
1668 .disconnect = dlfb_usb_disconnect,
1669 .id_table = id_table,
1670};
1671
1672static int __init dlfb_module_init(void)
1673{
1674 int res;
1675
1676 res = usb_register(&dlfb_driver);
1677 if (res)
1678 err("usb_register failed. Error number %d", res);
1679
1680 return res;
1681}
1682
1683static void __exit dlfb_module_exit(void)
1684{
1685 usb_deregister(&dlfb_driver);
1686}
1687
1688module_init(dlfb_module_init);
1689module_exit(dlfb_module_exit);
1690
1691static void dlfb_urb_completion(struct urb *urb)
1692{
1693 struct urb_node *unode = urb->context;
1694 struct dlfb_data *dev = unode->dev;
1695 unsigned long flags;
1696
1697
1698 if (urb->status) {
1699 if (!(urb->status == -ENOENT ||
1700 urb->status == -ECONNRESET ||
1701 urb->status == -ESHUTDOWN)) {
1702 pr_err("%s - nonzero write bulk status received: %d\n",
1703 __func__, urb->status);
1704 atomic_set(&dev->lost_pixels, 1);
1705 }
1706 }
1707
1708 urb->transfer_buffer_length = dev->urbs.size;
1709
1710 spin_lock_irqsave(&dev->urbs.lock, flags);
1711 list_add_tail(&unode->entry, &dev->urbs.list);
1712 dev->urbs.available++;
1713 spin_unlock_irqrestore(&dev->urbs.lock, flags);
1714
1715
1716
1717
1718
1719 if (fb_defio)
1720 schedule_delayed_work(&unode->release_urb_work, 0);
1721 else
1722 up(&dev->urbs.limit_sem);
1723}
1724
1725static void dlfb_free_urb_list(struct dlfb_data *dev)
1726{
1727 int count = dev->urbs.count;
1728 struct list_head *node;
1729 struct urb_node *unode;
1730 struct urb *urb;
1731 int ret;
1732 unsigned long flags;
1733
1734 pr_notice("Waiting for completes and freeing all render urbs\n");
1735
1736
1737 while (count--) {
1738
1739
1740 ret = down_interruptible(&dev->urbs.limit_sem);
1741 if (ret)
1742 break;
1743
1744 spin_lock_irqsave(&dev->urbs.lock, flags);
1745
1746 node = dev->urbs.list.next;
1747 list_del_init(node);
1748
1749 spin_unlock_irqrestore(&dev->urbs.lock, flags);
1750
1751 unode = list_entry(node, struct urb_node, entry);
1752 urb = unode->urb;
1753
1754
1755 usb_free_coherent(urb->dev, dev->urbs.size,
1756 urb->transfer_buffer, urb->transfer_dma);
1757 usb_free_urb(urb);
1758 kfree(node);
1759 }
1760
1761}
1762
1763static int dlfb_alloc_urb_list(struct dlfb_data *dev, int count, size_t size)
1764{
1765 int i = 0;
1766 struct urb *urb;
1767 struct urb_node *unode;
1768 char *buf;
1769
1770 spin_lock_init(&dev->urbs.lock);
1771
1772 dev->urbs.size = size;
1773 INIT_LIST_HEAD(&dev->urbs.list);
1774
1775 while (i < count) {
1776 unode = kzalloc(sizeof(struct urb_node), GFP_KERNEL);
1777 if (!unode)
1778 break;
1779 unode->dev = dev;
1780
1781 INIT_DELAYED_WORK(&unode->release_urb_work,
1782 dlfb_release_urb_work);
1783
1784 urb = usb_alloc_urb(0, GFP_KERNEL);
1785 if (!urb) {
1786 kfree(unode);
1787 break;
1788 }
1789 unode->urb = urb;
1790
1791 buf = usb_alloc_coherent(dev->udev, MAX_TRANSFER, GFP_KERNEL,
1792 &urb->transfer_dma);
1793 if (!buf) {
1794 kfree(unode);
1795 usb_free_urb(urb);
1796 break;
1797 }
1798
1799
1800 usb_fill_bulk_urb(urb, dev->udev, usb_sndbulkpipe(dev->udev, 1),
1801 buf, size, dlfb_urb_completion, unode);
1802 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1803
1804 list_add_tail(&unode->entry, &dev->urbs.list);
1805
1806 i++;
1807 }
1808
1809 sema_init(&dev->urbs.limit_sem, i);
1810 dev->urbs.count = i;
1811 dev->urbs.available = i;
1812
1813 pr_notice("allocated %d %d byte urbs\n", i, (int) size);
1814
1815 return i;
1816}
1817
1818static struct urb *dlfb_get_urb(struct dlfb_data *dev)
1819{
1820 int ret = 0;
1821 struct list_head *entry;
1822 struct urb_node *unode;
1823 struct urb *urb = NULL;
1824 unsigned long flags;
1825
1826
1827 ret = down_timeout(&dev->urbs.limit_sem, GET_URB_TIMEOUT);
1828 if (ret) {
1829 atomic_set(&dev->lost_pixels, 1);
1830 pr_warn("wait for urb interrupted: %x available: %d\n",
1831 ret, dev->urbs.available);
1832 goto error;
1833 }
1834
1835 spin_lock_irqsave(&dev->urbs.lock, flags);
1836
1837 BUG_ON(list_empty(&dev->urbs.list));
1838 entry = dev->urbs.list.next;
1839 list_del_init(entry);
1840 dev->urbs.available--;
1841
1842 spin_unlock_irqrestore(&dev->urbs.lock, flags);
1843
1844 unode = list_entry(entry, struct urb_node, entry);
1845 urb = unode->urb;
1846
1847error:
1848 return urb;
1849}
1850
1851static int dlfb_submit_urb(struct dlfb_data *dev, struct urb *urb, size_t len)
1852{
1853 int ret;
1854
1855 BUG_ON(len > dev->urbs.size);
1856
1857 urb->transfer_buffer_length = len;
1858 ret = usb_submit_urb(urb, GFP_KERNEL);
1859 if (ret) {
1860 dlfb_urb_completion(urb);
1861 atomic_set(&dev->lost_pixels, 1);
1862 pr_err("usb_submit_urb error %x\n", ret);
1863 }
1864 return ret;
1865}
1866
1867module_param(console, bool, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP);
1868MODULE_PARM_DESC(console, "Allow fbcon to consume first framebuffer found");
1869
1870module_param(fb_defio, bool, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP);
1871MODULE_PARM_DESC(fb_defio, "Enable fb_defio mmap support. *Experimental*");
1872
1873MODULE_AUTHOR("Roberto De Ioris <roberto@unbit.it>, "
1874 "Jaya Kumar <jayakumar.lkml@gmail.com>, "
1875 "Bernie Thompson <bernie@plugable.com>");
1876MODULE_DESCRIPTION("DisplayLink kernel framebuffer driver");
1877MODULE_LICENSE("GPL");
1878
1879