From 962ace78510e2eee5ca9baffb92c44a4dcf46ba2 Mon Sep 17 00:00:00 2001 From: Koen Kooi Date: Fri, 5 Jun 2009 17:27:52 +0200 Subject: kernel-module-udlfb: update to 0.2.2 --- recipes/libdlo/kernel-module-udlfb.bb | 2 +- recipes/libdlo/kernel-module-udlfb/dlfb.h | 234 ------- recipes/libdlo/kernel-module-udlfb/udlfb.c | 1014 +++++++++++++++++----------- recipes/libdlo/kernel-module-udlfb/udlfb.h | 213 ++++++ 4 files changed, 849 insertions(+), 614 deletions(-) delete mode 100644 recipes/libdlo/kernel-module-udlfb/dlfb.h create mode 100644 recipes/libdlo/kernel-module-udlfb/udlfb.h (limited to 'recipes/libdlo') diff --git a/recipes/libdlo/kernel-module-udlfb.bb b/recipes/libdlo/kernel-module-udlfb.bb index f1352ef0c1..52cde6b47d 100644 --- a/recipes/libdlo/kernel-module-udlfb.bb +++ b/recipes/libdlo/kernel-module-udlfb.bb @@ -1,7 +1,7 @@ DESCRIPTION = "Framebuffer console driver for displaylink based usb devices" LICENSE = "GPLv2" -PV = "0.2" +PV = "0.2.2" SRC_URI = "file://udlfb.c \ file://dlfb.h \ diff --git a/recipes/libdlo/kernel-module-udlfb/dlfb.h b/recipes/libdlo/kernel-module-udlfb/dlfb.h deleted file mode 100644 index fdc33ca1c4..0000000000 --- a/recipes/libdlo/kernel-module-udlfb/dlfb.h +++ /dev/null @@ -1,234 +0,0 @@ -#define MAX_VMODES 4 -#define FB_BPP 16 - -#define AF_CONTROL "\xAF\x20\xFF\x00\xAF\x20\x20\x00\xAF\x20\x21\0\xAF\x20\x22\0\xAF\x20\x26\x28\xAF\x20\x27\x00\xAF\x20\x28\x00\xAF\x20\xFF\xFF\xAF\xA0" -#define STD_CHANNEL "\x57\xCD\xDC\xA7\x1C\x88\x5E\x15\x60\xFE\xC6\x97\x16\x3D\x47\xF2" - -// as libdlo -#define BUF_HIGH_WATER_MARK 1024 -#define BUF_SIZE 64*1024 - -// Data (and color functions) taken from libdlo (http://freedesktop.org/wiki/Software/libdlo) - - -/** Return red/green component of a 16 bpp colour number. */ -#define DLO_RG16(red, grn) (uint8_t)((((red) & 0xF8) | ((grn) >> 5)) & 0xFF) - -/** Return green/blue component of a 16 bpp colour number. */ -#define DLO_GB16(grn, blu) (uint8_t)(((((grn) & 0x1C) << 3) | ((blu) >> 3)) & 0xFF) - -/** Return 8 bpp colour number from red, green and blue components. */ -#define DLO_RGB8(red, grn, blu) ((((red) << 5) | (((grn) & 3) << 3) | ((blu) & 7)) & 0xFF) - -/** Return a 32 bpp colour number when given the three RGB components. */ -#define DLO_RGB(red,grn,blu) (u32)(((red) & 0xFF) | (((grn) & 0xFF) << 8) | (((blu) & 0xFF) << 16)) - -/** Read the red component (0..255) of a 32 bpp colour. */ -#define DLO_RGB_GETRED(col) (uint8_t)((col) & 0xFF) - -/** Read the green component (0..255) of a 32 bpp colour. */ -#define DLO_RGB_GETGRN(col) (uint8_t)(((col) >> 8) & 0xFF) - -/** Read the blue component (0..255) of a 32 bpp colour. */ -#define DLO_RGB_GETBLU(col) (uint8_t)(((col) >> 16) & 0xFF) - - -static u32 read_pixel_565(const uint8_t * const ptr, const bool swap) -{ - u32 col; - uint16_t *pix = (uint16_t *)ptr; - uint8_t red, grn, blu; - - col = *pix; - red = (col & 0x001F) << 3; - grn = (col & 0x07E0) >> 3; - blu = (col & 0xF800) >> 8; - red = red | (red >> 5); - grn = grn | (grn >> 5); - blu = blu | (blu >> 5); - - return swap ? DLO_RGB(blu, grn, red) : DLO_RGB(red, grn, blu); -} - -static u16 rgb16(u32 col) -{ - uint8_t red = DLO_RGB_GETRED(col); - uint8_t grn = DLO_RGB_GETGRN(col); - uint8_t blu = DLO_RGB_GETBLU(col); - - return (DLO_RG16(red, grn) << 8) + DLO_GB16(grn, blu); -} - - - -struct dlfb_data { - struct usb_device *udev; - struct usb_interface *interface; - struct urb *tx_urb, *ctrl_urb ; - struct usb_ctrlrequest dr; - struct fb_info *info; - char *buf ; - char *bufend; - struct mutex bulk_mutex; - char edid[128]; - int screen_size; - int line_length; -}; - - -struct dlfb_video_mode { - - int width ; - int height; - int bpp; - int hz; - - char enable_data[146]; - char data[146]; -}; - -struct dlfb_video_mode dlfb_video_modes[MAX_VMODES] ; - -static void dlfb_bulk_callback(struct urb *urb) { - - struct dlfb_data *dev_info = urb->context; - - mutex_unlock(&dev_info->bulk_mutex); - -} - -static int dlfb_bulk_msg(struct dlfb_data *dev_info, int len) { - - int clen; - - /* - mutex_lock(&dev_info->bulk_mutex); - - usb_fill_bulk_urb(dev_info->tx_urb, dev_info->udev, usb_sndbulkpipe(dev_info->udev, 1), dev_info->buf, len, dlfb_bulk_callback, dev_info); - - dev_info->tx_urb->actual_length = 0; - - return usb_submit_urb(dev_info->tx_urb, GFP_NOIO); - */ - - return usb_bulk_msg(dev_info->udev, usb_sndbulkpipe(dev_info->udev, 1), dev_info->buf, len, &clen, 0); -} - - - -void dlfb_init_modes(void) { - - dlfb_video_modes[0].width = 800 ; - dlfb_video_modes[0].height = 480 ; - dlfb_video_modes[0].bpp = 16 ; - dlfb_video_modes[0].hz = 60 ; - memcpy(dlfb_video_modes[0].enable_data,"\x7A\x12\x36\x0B\xEF\x21\x74\xD1\xF0\x06\x8F\x38\xE8\x71\xB4\xCE",16); - memcpy(dlfb_video_modes[0].data,"" \ - "\x78\x67\x19\xF3\xB3\xD6\x5D\x7B\x4C\xCA\x26\x78\x41\x19\x19\xAC" \ - "\xFF\x38\xB3\x10\x71\x89\x6A\xEC\xA8\xC1\x4F\x1F\x77\x86\x5D\x7E" \ - "\xCE\xAF\x65\x7D\xFC\x30\x51\x67\x1F\x48\x30\x8E\x7A\x4B\x8A\xD4" \ - "\xCB\x62\x45\x58\x5C\x22\x1D\x56\x6E\x2F\x60\xE2\x06\x6D\xA1\xE3" \ - "\x82\x5F\x67\x95\x7A\x9F\x87\x43\xD8\x33\xEF\x0B\x5A\xDA\x09\x4F" \ - "\xD7\x25\x6F\xBC\xF8\xC7\x09\x9C\x12\xC3\xA7\x6F\xE7\xED\xA8\x70" \ - "\x8C\xB9\x65\x53\xDD\xA6\x7D\xDE\xD9\x4F\xDD\xD4\x6F\x28\xD6\x14" \ - "\xDC\x2D\x41\x53\x33\xD9\x0A\x86\x11\x3C\x41\x5A\x56\x48\xF9\x85" \ - "\x2B\x2F\x22\x66\x20\x39\xDA\xA1\x50\xCB\x5A\x58\x7D\x97\xFA\x2C" \ - "\x64\x9D",146); - - dlfb_video_modes[1].width = 1024 ; - dlfb_video_modes[1].height = 768 ; - dlfb_video_modes[1].bpp = 16 ; - dlfb_video_modes[1].hz = 60 ; - memcpy(dlfb_video_modes[1].enable_data,"\xB6\xF8\xFC\x00\xF3\xE4\x81\x1E\xC5\x60\xA3\x79\xE5\x35\xC5\x15",16); - memcpy(dlfb_video_modes[1].data,"" \ - "\xDD\x2A\x3A\x49\xE9\x99\xE3\xC8\xA0\xBA\x23\x3A\x3D\xEB\x21\xE4" \ - "\xA5\x54\x25\x0D\x51\xCC\xE6\x52\xA7\xD7\xCD\xFA\xD5\x9B\x5B\x41" \ - "\x0B\x49\xAB\xC6\xE3\x1A\xF2\x87\x81\x32\xF0\x3E\x40\x00\x51\x40" \ - "\x9E\x94\xF1\x22\xEE\xAC\xB2\xA2\x6B\x4D\xC4\x41\x5A\x9C\x45\x62" \ - "\x4F\x4E\x61\xDB\x1F\x0E\x79\x66\xE2\x20\x83\x9E\x2C\xAB\x28\x38" \ - "\xAC\xC1\x22\x81\xA5\x69\xFD\xFB\x26\x15\xF9\xC9\xFA\x90\xF2\x66" \ - "\x85\xC5\xAA\xA6\x4D\x8B\xC8\xA6\x03\x32\xDF\x98\xA9\x77\x9E\x57" \ - "\xEA\xC9\x9E\x29\xED\xFC\xC4\x78\x26\x0B\x2E\xC2\x41\x7C\x4A\xA3" \ - "\xAB\x66\x01\xA0\xE5\xA4\x8B\x80\xA0\x53\xE5\x5D\x59\x63\x62\xE8" \ - "\xFE\x6B",146); - - dlfb_video_modes[2].width = 1280 ; - dlfb_video_modes[2].height = 1024 ; - dlfb_video_modes[2].bpp = 16 ; - dlfb_video_modes[2].hz = 60 ; - memcpy(dlfb_video_modes[2].enable_data,"\x6A\xF0\x37\x50\x63\xEF\xD2\xA9\x6F\x75\x72\xBB\xC7\x7B\x6F\x1A",16); - memcpy(dlfb_video_modes[2].data,"" \ - "\x23\x4A\x78\x7C\xD1\xB8\x0E\x6B\x15\x93\x96\x77\x78\x44\xCC\x16" \ - "\x7F\xE3\xD7\x39\x3F\x2E\x99\xD2\xB9\x68\x8E\xC4\x1A\x9B\xF4\x35" \ - "\x61\xB5\x48\x5C\x94\xA6\x84\xB2\x88\x2B\x47\x84\x84\x73\x7F\x2C" \ - "\xD0\xC4\x3D\x5D\x20\x61\x4A\xB1\x73\x4C\xDD\x6A\xB4\xFD\xE9\x94" \ - "\x3C\xD1\x44\x0A\x08\xCD\xF5\xE5\xBD\x0D\x99\xCD\x9C\x2A\xC9\x06" \ - "\x1D\x22\x1C\xB1\x9A\x94\x95\x65\x3C\x43\x19\x73\x83\xF7\x51\x1F" \ - "\x5C\x3C\xE1\x59\xD5\xC3\xF2\x27\x28\xCE\x22\x7B\x2A\x70\x04\xE4" \ - "\xD9\xFE\x8A\x6E\x28\x27\xC5\x40\x4E\xF8\x83\x5B\x82\x41\xA6\x62" \ - "\xC1\x73\x3A\x5C\xF6\x90\x43\x39\xF2\xF5\x74\x80\x74\x44\xBD\xB1" \ - "\x08\x53",146); - - dlfb_video_modes[3].width = 1400 ; - dlfb_video_modes[3].height = 1050 ; - dlfb_video_modes[3].bpp = 16 ; - dlfb_video_modes[3].hz = 60 ; - memcpy(dlfb_video_modes[3].enable_data,"\x95\xCB\x91\xE5\xA8\x28\xFB\x87\xD5\x92\x1C\x44\x66\x57\x8A\x98",16); - memcpy(dlfb_video_modes[3].data,"" \ - "\xC6\x8C\x42\x4C\x95\xDA\xB4\x2F\xBD\xD9\x9E\xAD\x8F\x7B\x69\x15" \ - "\x1B\xDA\x06\x79\x23\x9E\x94\xF2\xC2\xE9\xBB\x34\x13\x6B\x9B\xB2" \ - "\xC1\x4E\xD8\x69\x81\x49\x6E\x64\xAF\xB2\x4E\x69\x24\x1A\xA8\xBB" \ - "\x4E\x11\x75\x38\xE6\xC9\x3D\xE9\x9A\xCC\x3B\xAA\x1F\xC4\x97\xD5" \ - "\x4A\x9D\xAA\xE7\x04\xF0\xB6\xD4\xBD\xE4\x41\xCF\xF8\xA2\x77\x0B" \ - "\x46\x9D\x3A\xBD\x73\xC0\x64\x76\x84\x2B\xD7\x11\xF3\x43\xB5\xF6" \ - "\xE9\x0B\xB3\x4E\x2B\x80\x98\x15\xDC\xDA\x46\xE8\xEC\xBD\x0B\x0E" \ - "\x64\x20\xF7\x17\x17\x33\x75\xBA\x30\x26\xDD\xFA\xA0\x99\x23\x11" \ - "\xF1\xDE\x80\xB7\xD6\xB0\xB7\xA2\xA9\xBD\x6D\x29\x42\x74\x75\x73" \ - "\xC5\x27",146); - -} - -int dlfb_set_video_mode(struct dlfb_data *dev_info, int width, int height) { - - int i, ret; - - for(i=0;ibuf, STD_CHANNEL, 16); - ret = usb_control_msg(dev_info->udev, usb_sndctrlpipe(dev_info->udev, 0), 0x12, (0x02 << 5), 0, 0, dev_info->buf, 16, 0); - printk("ret control msg 1 (STD_CHANNEL): %d\n", ret); - - memcpy(dev_info->buf, AF_CONTROL, sizeof(AF_CONTROL)-1); - ret = dlfb_bulk_msg(dev_info, sizeof(AF_CONTROL)-1); - printk("ret bulk 1: %d\n", ret); - - - memcpy(dev_info->buf, &dlfb_video_modes[i].enable_data, 16); - ret = usb_control_msg(dev_info->udev, usb_sndctrlpipe(dev_info->udev, 0), 0x12, (0x02 << 5), 0, 0, dev_info->buf, 16, 0); - printk("ret control msg 2: %d\n", ret); - - - // MODE_DATA - memcpy(dev_info->buf, &dlfb_video_modes[i].data, 146); - ret = dlfb_bulk_msg(dev_info, 146); - printk("ret bulk 2: %d\n", ret); - - memcpy(dev_info->buf, STD_CHANNEL, sizeof(STD_CHANNEL)-1); - ret = usb_control_msg(dev_info->udev, usb_sndctrlpipe(dev_info->udev, 0), 0x12, (0x02 << 5), 0, 0, dev_info->buf, sizeof(STD_CHANNEL)-1, 0); - printk("ret control msg 3: %d\n", ret); - - // flush - ret = dlfb_bulk_msg(dev_info, 0); - printk("ret bulk 3: %d\n", ret); - - dev_info->screen_size = width*height*(FB_BPP/8) ; - dev_info->line_length = width*(FB_BPP/8) ; - - return 0; - } - } - - return -1 ; -} diff --git a/recipes/libdlo/kernel-module-udlfb/udlfb.c b/recipes/libdlo/kernel-module-udlfb/udlfb.c index 32f2b30134..96fdb3e7d5 100644 --- a/recipes/libdlo/kernel-module-udlfb/udlfb.c +++ b/recipes/libdlo/kernel-module-udlfb/udlfb.c @@ -1,14 +1,16 @@ -/***************************************************************************** - * DLFB Kernel Driver * - * Version 0.2rc1 (udlfb) * - * (C) 2009 Roberto De Ioris * - * * - * This file is licensed under the GPLv2. See COPYING in the package. * - * Based on the amazing work of Florian Echtler and libdlo 0.1 * - * * - * * - * 22.05.09 First public (ugly) release * - *****************************************************************************/ +/************************************************************************************ + * DLFB Kernel Driver * + * Version 0.2 (udlfb) * + * (C) 2009 Roberto De Ioris * + * * + * This file is licensed under the GPLv2. See COPYING in the package. * + * Based on the amazing work of Florian Echtler and libdlo 0.1 * + * * + * * + * 05.06.09 release 0.2.2 (real screen blanking, rle compression, double buffer) * + * 31.05.09 release 0.2 * + * 22.05.09 First public (ugly) release * + ************************************************************************************/ #include #include @@ -20,472 +22,702 @@ #include #include -#include "dlfb.h" +#include "udlfb.h" +#define DRIVER_VERSION "DLFB 0.2" -#define DRIVER_VERSION "DLFB 0.2rc2" - - -// memory functions taken from vfb +/* memory functions taken from vfb */ static void *rvmalloc(unsigned long size) { - void *mem; - unsigned long adr; - - size = PAGE_ALIGN(size); - mem = vmalloc_32(size); - if (!mem) - return NULL; - - memset(mem, 0, size); /* Clear the ram out, no junk to the user */ - adr = (unsigned long) mem; - while (size > 0) { - SetPageReserved(vmalloc_to_page((void *)adr)); - adr += PAGE_SIZE; - size -= PAGE_SIZE; - } + void *mem; + unsigned long adr; + + size = PAGE_ALIGN(size); + mem = vmalloc_32(size); + if (!mem) + return NULL; + + memset(mem, 0, size); /* Clear the ram out, no junk to the user */ + adr = (unsigned long)mem; + while (size > 0) { + SetPageReserved(vmalloc_to_page((void *)adr)); + adr += PAGE_SIZE; + size -= PAGE_SIZE; + } - return mem; + return mem; } static void rvfree(void *mem, unsigned long size) { - unsigned long adr; + unsigned long adr; - if (!mem) - return; + if (!mem) + return; - adr = (unsigned long) mem; - while ((long) size > 0) { - ClearPageReserved(vmalloc_to_page((void *)adr)); - adr += PAGE_SIZE; - size -= PAGE_SIZE; - } - vfree(mem); + adr = (unsigned long)mem; + while ((long)size > 0) { + ClearPageReserved(vmalloc_to_page((void *)adr)); + adr += PAGE_SIZE; + size -= PAGE_SIZE; + } + vfree(mem); } -static int dlfb_mmap(struct fb_info *info, - struct vm_area_struct *vma) +static int dlfb_mmap(struct fb_info *info, struct vm_area_struct *vma) { - unsigned long start = vma->vm_start; - unsigned long size = vma->vm_end - vma->vm_start; - unsigned long offset = vma->vm_pgoff << PAGE_SHIFT; - unsigned long page, pos; + unsigned long start = vma->vm_start; + unsigned long size = vma->vm_end - vma->vm_start; + unsigned long offset = vma->vm_pgoff << PAGE_SHIFT; + unsigned long page, pos; printk("MMAP: %lu %u\n", offset + size, info->fix.smem_len); - if (offset + size > info->fix.smem_len) { - return -EINVAL; - } - - pos = (unsigned long)info->fix.smem_start + offset; + if (offset + size > info->fix.smem_len) + return -EINVAL; - while (size > 0) { - page = vmalloc_to_pfn((void *)pos); - if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) { - return -EAGAIN; - } - start += PAGE_SIZE; - pos += PAGE_SIZE; - if (size > PAGE_SIZE) - size -= PAGE_SIZE; - else - size = 0; - } + pos = (unsigned long)info->fix.smem_start + offset; - vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */ - return 0; + while (size > 0) { + page = vmalloc_to_pfn((void *)pos); + if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) + return -EAGAIN; -} + start += PAGE_SIZE; + pos += PAGE_SIZE; + if (size > PAGE_SIZE) + size -= PAGE_SIZE; + else + size = 0; + } -// + vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */ + return 0; +} -//ioctl structure +/* ioctl structure */ struct dloarea { - int x,y; - int w,h; + int x, y; + int w, h; + int x2, y2; }; /* - static struct usb_device_id id_table [] = { { USB_DEVICE(0x17e9, 0x023d) }, - { } + { } }; - */ -static struct usb_device_id id_table [] = { - { .idVendor = 0x17e9, .match_flags = USB_DEVICE_ID_MATCH_VENDOR, }, - { }, +static struct usb_device_id id_table[] = { + {.idVendor = 0x17e9, .match_flags = USB_DEVICE_ID_MATCH_VENDOR,}, + {}, }; +MODULE_DEVICE_TABLE(usb, id_table); + +static struct usb_driver dlfb_driver; +// thanks to Henrik Bjerregaard Pedersen for this function +static char * +rle_compress16(uint16_t *src, char *dst, int rem) +{ + int rl; + uint16_t pix0; + char *end_if_raw = dst + 6 + 2 * rem; -MODULE_DEVICE_TABLE (usb, id_table); + dst += 6; // header will be filled in if RLE is worth it -static struct usb_driver dlfb_driver; + while (rem && dst < end_if_raw) { + char *start = (char *)src; -static int image_blit(struct dlfb_data *dev_info, int x, int y, int width, int height, char *data) { - - int i,j,base ; - int rem = width ; + pix0 = *src++; + rl = 1; + rem--; + while (rem && *src == pix0) + rem--, rl++, src++; + *dst++ = rl; + *dst++ = start[1]; + *dst++ = start[0]; + } + + return dst; +} + +/* +Thanks to Henrik Bjerregaard Pedersen for rle implementation and code refactoring. +Next step is huffman compression. +*/ + +static int +image_blit(struct dlfb_data *dev_info, int x, int y, int width, int height, + char *data) +{ + + int i, j, base; + int rem = width; int ret; - u32 col; - u16 dlocol ; - - char *bufptr ; + int firstdiff, thistime; + + char *bufptr; - if (x+width > dev_info->info->var.xres) { + if (x + width > dev_info->info->var.xres) { return -EINVAL; } - if (y+height > dev_info->info->var.yres) { + if (y + height > dev_info->info->var.yres) { return -EINVAL; } + mutex_lock(&dev_info->bulk_mutex); - base = (dev_info->info->var.xres*2*y)+(x*2) ; + base = dev_info->base16 + ( (dev_info->info->var.xres * 2 * y) + (x * 2) ); - data += (dev_info->info->var.xres*2*y)+(x*2) ; + data += (dev_info->info->var.xres * 2 * y) + (x * 2); //printk("IMAGE_BLIT\n"); - bufptr = dev_info->buf ; + bufptr = dev_info->buf; - for(i = y;ibufend - bufptr < BUF_HIGH_WATER_MARK) { - ret = dlfb_bulk_msg(dev_info, bufptr-dev_info->buf); - bufptr = dev_info->buf ; + ret = dlfb_bulk_msg(dev_info, bufptr - dev_info->buf); + bufptr = dev_info->buf; } - rem = width ; + rem = width; //printk("WRITING LINE %d\n", i); - while(rem) { + while (rem) { if (dev_info->bufend - bufptr < BUF_HIGH_WATER_MARK) { - ret = dlfb_bulk_msg(dev_info, bufptr-dev_info->buf); - bufptr = dev_info->buf ; - } - - *bufptr++ = 0xAF ; - *bufptr++ = 0x68 ; - - *bufptr++ = (char)(base >> 16) ; - *bufptr++ = (char)(base >> 8) ; - *bufptr++ = (char)(base) ; - - if (rem > 255) { - *bufptr++ = 255 ; - for(j=0;j<510;j+=2) { - col = read_pixel_565(data+j, 1); - dlocol = ntohs(rgb16(col)); - memcpy(bufptr, &dlocol, 2); - bufptr+=2; + ret = + dlfb_bulk_msg(dev_info, + bufptr - dev_info->buf); + bufptr = dev_info->buf; + } + + // number of pixels to consider this time + thistime = rem; + if (thistime > 255) + thistime = 255; + + // find position of first pixel that has changed + firstdiff = -1; + for (j = 0; j < thistime * 2; j++) { + if (dev_info-> + backing_buffer[ base - dev_info->base16 + j] != + data[j]) { + firstdiff = j/2; + break; } - rem-=255; - base+=510; - data+= 510; - } - else { - *bufptr++ = rem ; - for(j=0;j= 0) { + char *end_of_rle; + + end_of_rle = + rle_compress16((uint16_t *)(data + firstdiff * 2), + bufptr, thistime-firstdiff); + + if (end_of_rle < bufptr + 6 + 2 * (thistime-firstdiff)) { + bufptr[0] = 0xAF; + bufptr[1] = 0x69; + + bufptr[2] = (char)((base+firstdiff*2) >> 16); + bufptr[3] = (char)((base+firstdiff*2) >> 8); + bufptr[4] = (char)(base+firstdiff*2); + bufptr[5] = thistime-firstdiff; + + bufptr = end_of_rle; + + } else { + // fallback to raw (or some other encoding?) + *bufptr++ = 0xAF; + *bufptr++ = 0x68; + + *bufptr++ = (char)((base+firstdiff*2) >> 16); + *bufptr++ = (char)((base+firstdiff*2) >> 8); + *bufptr++ = (char)(base+firstdiff*2); + *bufptr++ = thistime-firstdiff; + // PUT COMPRESSION HERE + for (j = firstdiff * 2; j < thistime * 2; j += 2) { + *bufptr++ = data[j + 1]; + *bufptr++ = data[j]; + } } + } - base += (dev_info->info->var.xres*2)-(width*2) ; - data += (dev_info->info->var.xres*2)-(width*2) ; + base += thistime * 2; + data += thistime * 2; + rem -= thistime; + } - } + memcpy(dev_info->backing_buffer + (base-dev_info->base16) - (width * 2), + data - (width * 2), width * 2); + + base += (dev_info->info->var.xres * 2) - (width * 2); + data += (dev_info->info->var.xres * 2) - (width * 2); + + } if (bufptr > dev_info->buf) { - ret = dlfb_bulk_msg(dev_info, bufptr-dev_info->buf); + ret = dlfb_bulk_msg(dev_info, bufptr - dev_info->buf); } - return base ; -} + mutex_unlock(&dev_info->bulk_mutex); + + return base; -static int draw_rect(struct dlfb_data *dev_info, int x, int y, int width, int height, unsigned char red, unsigned char green, unsigned char blue) { +} +static int +draw_rect(struct dlfb_data *dev_info, int x, int y, int width, int height, + unsigned char red, unsigned char green, unsigned char blue) +{ - int i,base ; - int ret ; - unsigned short col = (((((red) & 0xF8) | ((green) >> 5)) & 0xFF) << 8) + (((((green) & 0x1C) << 3) | ((blue) >> 3)) & 0xFF) ; - int rem = width ; + int i, j, base; + int ret; + unsigned short col = + (((((red) & 0xF8) | ((green) >> 5)) & 0xFF) << 8) + + (((((green) & 0x1C) << 3) | ((blue) >> 3)) & 0xFF); + int rem = width; - char *bufptr ; + char *bufptr; - if (x+width > dev_info->info->var.xres) { + if (x + width > dev_info->info->var.xres) return -EINVAL; - } - if (y+height > dev_info->info->var.yres) { + if (y + height > dev_info->info->var.yres) return -EINVAL; - } - base = (dev_info->info->var.xres*2*y)+(x*2) ; + mutex_lock(&dev_info->bulk_mutex); + + base = dev_info->base16 + (dev_info->info->var.xres * 2 * y) + (x * 2); - bufptr = dev_info->buf ; + bufptr = dev_info->buf; - for(i = y;ibacking_buffer[base - dev_info->base16 + j] = (char)(col >> 8); + dev_info->backing_buffer[base - dev_info->base16 + j + 1] = (char)(col); + } if (dev_info->bufend - bufptr < BUF_HIGH_WATER_MARK) { - ret = dlfb_bulk_msg(dev_info, bufptr-dev_info->buf); - bufptr = dev_info->buf ; - } + ret = dlfb_bulk_msg(dev_info, bufptr - dev_info->buf); + bufptr = dev_info->buf; + } - rem = width ; + rem = width; - while(rem) { + while (rem) { if (dev_info->bufend - bufptr < BUF_HIGH_WATER_MARK) { - ret = dlfb_bulk_msg(dev_info, bufptr-dev_info->buf); - bufptr = dev_info->buf ; - } + ret = + dlfb_bulk_msg(dev_info, + bufptr - dev_info->buf); + bufptr = dev_info->buf; + } - *bufptr++ = 0xAF ; - *bufptr++ = 0x69 ; + *bufptr++ = 0xAF; + *bufptr++ = 0x69; - *bufptr++ = (char)(base >> 16) ; - *bufptr++ = (char)(base >> 8) ; - *bufptr++ = (char)(base) ; + *bufptr++ = (char)(base >> 16); + *bufptr++ = (char)(base >> 8); + *bufptr++ = (char)(base); if (rem > 255) { - *bufptr++ = 255 ; - *bufptr++ = 255 ; - rem-=255; - base+=255*2; - } - else { - *bufptr++ = rem ; - *bufptr++ = rem ; - base+= rem*2 ; - rem = 0 ; + *bufptr++ = 255; + *bufptr++ = 255; + rem -= 255; + base += 255 * 2; + } else { + *bufptr++ = rem; + *bufptr++ = rem; + base += rem * 2; + rem = 0; } - *bufptr++ = (char) (col >> 8) ; - *bufptr++ = (char) (col) ; + *bufptr++ = (char)(col >> 8); + *bufptr++ = (char)(col); } - base+= (dev_info->info->var.xres*2)-(width*2) ; - + base += (dev_info->info->var.xres * 2) - (width * 2); + } - if (bufptr > dev_info->buf) { - ret = dlfb_bulk_msg(dev_info, bufptr-dev_info->buf); - } + if (bufptr > dev_info->buf) + ret = dlfb_bulk_msg(dev_info, bufptr - dev_info->buf); + + mutex_unlock(&dev_info->bulk_mutex); - return 1 ; + return 1; +} + +static void swapfb(struct dlfb_data *dev_info) { + + int tmpbase; + char *bufptr; + + mutex_lock(&dev_info->bulk_mutex); + + tmpbase = dev_info->base16 ; + + dev_info->base16 = dev_info->base16d; + dev_info->base16d = tmpbase; + + bufptr = dev_info->buf; + + bufptr = dlfb_set_register(bufptr, 0xFF, 0x00); + + // set addresses + bufptr = + dlfb_set_register(bufptr, 0x20, + (char)(dev_info->base16 >> 16)); + bufptr = + dlfb_set_register(bufptr, 0x21, + (char)(dev_info->base16 >> 8)); + bufptr = + dlfb_set_register(bufptr, 0x22, + (char)(dev_info->base16)); + + bufptr = dlfb_set_register(bufptr, 0xFF, 0x00); + + dlfb_bulk_msg(dev_info, bufptr - dev_info->buf); + + mutex_unlock(&dev_info->bulk_mutex); } -static int copyarea(struct dlfb_data *dev_info, int dx, int dy, int sx, int sy, int width, int height) { +static int copyfb(struct dlfb_data *dev_info) +{ + int base; + int source; + int rem; + int i, ret; + + char *bufptr; + + + base = dev_info->base16d; + + mutex_lock(&dev_info->bulk_mutex); + + source = dev_info->base16; + + bufptr = dev_info->buf; + + for (i = 0; i < dev_info->info->var.yres; i++) { + + if (dev_info->bufend - bufptr < BUF_HIGH_WATER_MARK) { + ret = dlfb_bulk_msg(dev_info, bufptr - dev_info->buf); + bufptr = dev_info->buf; + } + + rem = dev_info->info->var.xres; + + while (rem) { + + if (dev_info->bufend - bufptr < BUF_HIGH_WATER_MARK) { + ret = + dlfb_bulk_msg(dev_info, + bufptr - dev_info->buf); + bufptr = dev_info->buf; + + } + + *bufptr++ = 0xAF; + *bufptr++ = 0x6A; + + *bufptr++ = (char)(base >> 16); + *bufptr++ = (char)(base >> 8); + *bufptr++ = (char)(base); + + if (rem > 255) { + *bufptr++ = 255; + *bufptr++ = (char)(source >> 16); + *bufptr++ = (char)(source >> 8); + *bufptr++ = (char)(source); + + rem -= 255; + base += 255 * 2; + source += 255 * 2; + + } else { + *bufptr++ = rem; + *bufptr++ = (char)(source >> 16); + *bufptr++ = (char)(source >> 8); + *bufptr++ = (char)(source); + + base += rem * 2; + source += rem * 2; + rem = 0; + } + } + } + + if (bufptr > dev_info->buf) + ret = dlfb_bulk_msg(dev_info, bufptr - dev_info->buf); + + mutex_unlock(&dev_info->bulk_mutex); + + return 1; + +} - int base ; - int source ; - int rem ; +static int +copyarea(struct dlfb_data *dev_info, int dx, int dy, int sx, int sy, + int width, int height) +{ + int base; + int source; + int rem; int i, ret; - char *bufptr ; + char *bufptr; - if (dx+width > dev_info->info->var.xres) { + if (dx + width > dev_info->info->var.xres) return -EINVAL; - } - if (dy+height > dev_info->info->var.yres) { + if (dy + height > dev_info->info->var.yres) return -EINVAL; - } - base = (dev_info->info->var.xres*2*dy)+(dx*2) ; - source = (dev_info->info->var.xres*2*sy)+(sx*2) ; + mutex_lock(&dev_info->bulk_mutex); - bufptr = dev_info->buf ; + base = + dev_info->base16 + (dev_info->info->var.xres * 2 * dy) + (dx * 2); + source = (dev_info->info->var.xres * 2 * sy) + (sx * 2); - for(i = sy;ibuf; + + for (i = sy; i < sy + height; i++) { + + memcpy(dev_info->backing_buffer + base - dev_info->base16, + dev_info->backing_buffer + source, width * 2); if (dev_info->bufend - bufptr < BUF_HIGH_WATER_MARK) { - ret = dlfb_bulk_msg(dev_info, bufptr-dev_info->buf); - bufptr = dev_info->buf ; - } + ret = dlfb_bulk_msg(dev_info, bufptr - dev_info->buf); + bufptr = dev_info->buf; + } - rem = width ; + rem = width; - while(rem) { + while (rem) { if (dev_info->bufend - bufptr < BUF_HIGH_WATER_MARK) { - ret = dlfb_bulk_msg(dev_info, bufptr-dev_info->buf); - bufptr = dev_info->buf ; - } + ret = + dlfb_bulk_msg(dev_info, + bufptr - dev_info->buf); + bufptr = dev_info->buf; + } - *bufptr++ = 0xAF ; - *bufptr++ = 0x6A ; - - *bufptr++ = (char)(base >> 16) ; - *bufptr++ = (char)(base >> 8) ; - *bufptr++ = (char)(base) ; + *bufptr++ = 0xAF; + *bufptr++ = 0x6A; - if (rem > 255) { - *bufptr++ = 255 ; - *bufptr++ = (char)(source >> 16) ; - *bufptr++ = (char)(source >> 8) ; - *bufptr++ = (char)(source) ; - - rem-=255; - base+=255*2; - source+=255*2; + *bufptr++ = (char)(base >> 16); + *bufptr++ = (char)(base >> 8); + *bufptr++ = (char)(base); - } - else { - *bufptr++ = rem ; - *bufptr++ = (char)(source >> 16) ; - *bufptr++ = (char)(source >> 8) ; - *bufptr++ = (char)(source) ; - - base+= rem*2 ; - source+= rem*2 ; - rem = 0 ; - } - + if (rem > 255) { + *bufptr++ = 255; + *bufptr++ = (char)(source >> 16); + *bufptr++ = (char)(source >> 8); + *bufptr++ = (char)(source); + + rem -= 255; + base += 255 * 2; + source += 255 * 2; + + } else { + *bufptr++ = rem; + *bufptr++ = (char)(source >> 16); + *bufptr++ = (char)(source >> 8); + *bufptr++ = (char)(source); + + base += rem * 2; + source += rem * 2; + rem = 0; + } } - base+= (dev_info->info->var.xres*2)-(width*2) ; - source += (dev_info->info->var.xres*2)-(width*2) ; - + base += (dev_info->info->var.xres * 2) - (width * 2); + source += (dev_info->info->var.xres * 2) - (width * 2); } - if (bufptr > dev_info->buf) { - ret = dlfb_bulk_msg(dev_info, bufptr-dev_info->buf); - } + if (bufptr > dev_info->buf) + ret = dlfb_bulk_msg(dev_info, bufptr - dev_info->buf); + + mutex_unlock(&dev_info->bulk_mutex); - return 1; } -void dlfb_copyarea(struct fb_info *info, const struct fb_copyarea *area) { +static void dlfb_copyarea(struct fb_info *info, const struct fb_copyarea *area) +{ - struct dlfb_data *dev = info->par; + struct dlfb_data *dev = info->par; - copyarea(dev, area->dx, area->dy, area->sx, area->sy, area->width, area->height) ; - + copyarea(dev, area->dx, area->dy, area->sx, area->sy, area->width, + area->height); - //printk("COPY AREA %d %d %d %d %d %d !!!\n", area->dx, area->dy, area->sx, area->sy, area->width, area->height); + /* printk("COPY AREA %d %d %d %d %d %d !!!\n", area->dx, area->dy, area->sx, area->sy, area->width, area->height); */ } -void dlfb_imageblit(struct fb_info *info, const struct fb_image *image) { +static void dlfb_imageblit(struct fb_info *info, const struct fb_image *image) +{ int ret; struct dlfb_data *dev = info->par; - //printk("IMAGE BLIT (1) %d %d %d %d DEPTH %d {%p}!!!\n", image->dx, image->dy, image->width, image->height, image->depth, dev->udev); + /* printk("IMAGE BLIT (1) %d %d %d %d DEPTH %d {%p}!!!\n", image->dx, image->dy, image->width, image->height, image->depth, dev->udev); */ cfb_imageblit(info, image); - ret = image_blit(dev, image->dx, image->dy, image->width, image->height, info->screen_base); - //printk("IMAGE BLIT (2) %d %d %d %d DEPTH %d {%p} %d!!!\n", image->dx, image->dy, image->width, image->height, image->depth, dev->udev, ret); + ret = + image_blit(dev, image->dx, image->dy, image->width, image->height, + info->screen_base); + /* printk("IMAGE BLIT (2) %d %d %d %d DEPTH %d {%p} %d!!!\n", image->dx, image->dy, image->width, image->height, image->depth, dev->udev, ret); */ } -void dlfb_fillrect(struct fb_info *info, const struct fb_fillrect *region) { +static void dlfb_fillrect(struct fb_info *info, const struct fb_fillrect *region) +{ - unsigned char red, green, blue ; + unsigned char red, green, blue; struct dlfb_data *dev = info->par; - + memcpy(&red, ®ion->color, 1); - memcpy(&green, ®ion->color+1, 1); - memcpy(&blue, ®ion->color+2, 1); - draw_rect(dev, region->dx, region->dy, region->width, region->height, red, green, blue); - //printk("FILL RECT %d %d !!!\n", region->dx, region->dy); - + memcpy(&green, ®ion->color + 1, 1); + memcpy(&blue, ®ion->color + 2, 1); + draw_rect(dev, region->dx, region->dy, region->width, region->height, + red, green, blue); + /* printk("FILL RECT %d %d !!!\n", region->dx, region->dy); */ + } -static int dlfb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg) { +static int dlfb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg) +{ - struct dlfb_data *dev = info->par; - struct dloarea *area ; + struct dlfb_data *dev_info = info->par; + struct dloarea *area = (struct dloarea *)arg; - area = (struct dloarea *) arg ; + if (cmd == 0xAA || cmd == 0xAB) { - if (area->x < 0) - area->x = 0 ; - if (area->x > info->var.xres) - area->x = info->var.xres ; + if (area->x < 0) + area->x = 0; - if (area->y < 0) - area->y = 0 ; + if (area->x > info->var.xres) + area->x = info->var.xres; - if (area->y > info->var.yres) - area->y = info->var.yres ; + if (area->y < 0) + area->y = 0; - //printk("REDRAW IOCTL %d %d %d %d\n", area->x, area->y, area->w, area->h); + if (area->y > info->var.yres) + area->y = info->var.yres; + } + + if (cmd == 0xAA) { + image_blit(dev_info, area->x, area->y, area->w, area->h, + info->screen_base); + } + if (cmd == 0xAC) { + copyfb(dev_info); + image_blit(dev_info, area->x, area->y, area->w, area->h, + info->screen_base); + swapfb(dev_info); + } + else if (cmd == 0xAB) { + + if (area->x2 < 0) + area->x2 = 0; + + if (area->y2 < 0) + area->y2 = 0; - image_blit(dev, area->x, area->y, area->w, area->h, info->screen_base); - return 0 ; + copyarea(dev_info, + area->x2, area->y2, area->x, area->y, area->w, area->h); + } + return 0; } +/* taken from vesafb */ + +static int +dlfb_setcolreg(unsigned regno, unsigned red, unsigned green, + unsigned blue, unsigned transp, struct fb_info *info) +{ + int err = 0; + + if (regno >= info->cmap.len) + return 1; + + if (regno < 16) { + if (info->var.red.offset == 10) { + /* 1:5:5:5 */ + ((u32 *) (info->pseudo_palette))[regno] = + ((red & 0xf800) >> 1) | + ((green & 0xf800) >> 6) | ((blue & 0xf800) >> 11); + } else { + /* 0:5:6:5 */ + ((u32 *) (info->pseudo_palette))[regno] = + ((red & 0xf800)) | + ((green & 0xfc00) >> 5) | ((blue & 0xf800) >> 11); + } + } -// taken from vesafb + return err; +} -static int dlfb_setcolreg(unsigned regno, unsigned red, unsigned green, - unsigned blue, unsigned transp, - struct fb_info *info) +static int dlfb_release(struct fb_info *info, int user) { - int err = 0; - - if (regno >= info->cmap.len) - return 1; - - if (regno < 16) { - if (info->var.red.offset == 10) { - /* 1:5:5:5 */ - ((u32*) (info->pseudo_palette))[regno] = - ((red & 0xf800) >> 1) | - ((green & 0xf800) >> 6) | - ((blue & 0xf800) >> 11); - } else { - /* 0:5:6:5 */ - ((u32*) (info->pseudo_palette))[regno] = - ((red & 0xf800) ) | - ((green & 0xfc00) >> 5) | - ((blue & 0xf800) >> 11); - } - } + struct dlfb_data *dev_info = info->par; + image_blit(dev_info, 0, 0, info->var.xres, info->var.yres, + info->screen_base); + return 0; +} + +static int dlfb_blank(int blank_mode, struct fb_info *info) +{ + struct dlfb_data *dev_info = info->par; + char *bufptr = dev_info->buf; - return err; + bufptr = dlfb_set_register(bufptr, 0xFF, 0x00); + if (blank_mode != FB_BLANK_UNBLANK) { + bufptr = dlfb_set_register(bufptr, 0x1F, 0x01); + } + else { + bufptr = dlfb_set_register(bufptr, 0x1F, 0x00); + } + bufptr = dlfb_set_register(bufptr, 0xFF, 0xFF); + + dlfb_bulk_msg(dev_info, bufptr - dev_info->buf); + + return 0; } static struct fb_ops dlfb_ops = { - - .fb_setcolreg = dlfb_setcolreg, + .fb_setcolreg = dlfb_setcolreg, .fb_fillrect = dlfb_fillrect, .fb_copyarea = dlfb_copyarea, .fb_imageblit = dlfb_imageblit, - .fb_mmap = dlfb_mmap, - .fb_ioctl = dlfb_ioctl, + .fb_mmap = dlfb_mmap, + .fb_ioctl = dlfb_ioctl, + .fb_release = dlfb_release, + .fb_blank = dlfb_blank, }; -static int dlfb_probe(struct usb_interface *interface, const struct usb_device_id *id) +static int +dlfb_probe(struct usb_interface *interface, const struct usb_device_id *id) { - struct dlfb_data *dev_info ; + struct dlfb_data *dev_info; struct fb_info *info; - int i ; - - int ret ; - char rbuf[4] ; - + int i; + int ret; + char rbuf[4]; dev_info = kzalloc(sizeof(*dev_info), GFP_KERNEL); if (dev_info == NULL) { @@ -493,36 +725,47 @@ static int dlfb_probe(struct usb_interface *interface, const struct usb_device_i return -ENOMEM; } - mutex_init(&dev_info->bulk_mutex); + mutex_init(&dev_info->bulk_mutex); dev_info->udev = usb_get_dev(interface_to_usbdev(interface)); - dev_info->interface = interface; - + dev_info->interface = interface; + printk("DisplayLink device attached\n"); - // add framebuffer info to usb interface - usb_set_intfdata (interface, dev_info); + /* add framebuffer info to usb interface */ + usb_set_intfdata(interface, dev_info); - - dev_info->buf = kmalloc(BUF_SIZE , GFP_KERNEL); //usb_buffer_alloc(dev_info->udev, BUF_SIZE , GFP_KERNEL, &dev_info->tx_urb->transfer_dma); + dev_info->buf = kmalloc(BUF_SIZE, GFP_KERNEL); + /* usb_buffer_alloc(dev_info->udev, BUF_SIZE , GFP_KERNEL, &dev_info->tx_urb->transfer_dma); */ if (dev_info->buf == NULL) { printk("unable to allocate memory for dlfb commands\n"); goto out; } - dev_info->bufend = dev_info->buf + BUF_SIZE ; - - - ret = usb_control_msg(dev_info->udev, usb_rcvctrlpipe(dev_info->udev, 0), (0x06), (0x80 | (0x02 << 5)), 0, 0, rbuf, 4, 0) ; - printk("ret control msg 0: %d %x%x%x%x\n", ret, rbuf[0], rbuf[1], rbuf[2], rbuf[3]); - - for(i=0;i<128;i++) { - ret = usb_control_msg(dev_info->udev, usb_rcvctrlpipe(dev_info->udev, 0), (0x02), (0x80 | (0x02 << 5)), i << 8, 0xA1, rbuf, 2, 0) ; - //printk("ret control msg edid %d: %d [%d]\n",i, ret, rbuf[1]); + dev_info->bufend = dev_info->buf + BUF_SIZE; + + dev_info->tx_urb = usb_alloc_urb(0, GFP_KERNEL); + usb_fill_bulk_urb(dev_info->tx_urb, dev_info->udev, + usb_sndbulkpipe(dev_info->udev, 1), dev_info->buf, 0, + dlfb_bulk_callback, dev_info); + + ret = + usb_control_msg(dev_info->udev, usb_rcvctrlpipe(dev_info->udev, 0), + (0x06), (0x80 | (0x02 << 5)), 0, 0, rbuf, 4, 0); + printk("ret control msg 0: %d %x%x%x%x\n", ret, rbuf[0], rbuf[1], + rbuf[2], rbuf[3]); + + for (i = 0; i < 128; i++) { + ret = + usb_control_msg(dev_info->udev, + usb_rcvctrlpipe(dev_info->udev, 0), (0x02), + (0x80 | (0x02 << 5)), i << 8, 0xA1, rbuf, 2, + 0); + /* printk("ret control msg edid %d: %d [%d]\n",i, ret, rbuf[1]); */ dev_info->edid[i] = rbuf[1]; } - info = framebuffer_alloc( sizeof(u32) *256, &dev_info->udev->dev); + info = framebuffer_alloc(sizeof(u32) * 256, &dev_info->udev->dev); if (!info) { printk("non posso allocare il framebuffer displaylink"); @@ -533,111 +776,125 @@ static int dlfb_probe(struct usb_interface *interface, const struct usb_device_i printk("EDID XRES %d YRES %d\n", info->var.xres, info->var.yres); - if (dlfb_set_video_mode(dev_info, info->var.xres, info->var.yres) != 0) { + if (dlfb_set_video_mode(dev_info, info->var.xres, info->var.yres) != 0) goto out; - } - printk("found valid mode...\n"); - + printk("found valid mode...%d\n", info->var.pixclock); + info->pseudo_palette = info->par; - info->par = dev_info ; + info->par = dev_info; - dev_info->info = info ; + dev_info->info = info; - info->flags = FBINFO_DEFAULT | FBINFO_READS_FAST | FBINFO_HWACCEL_IMAGEBLIT | FBINFO_HWACCEL_COPYAREA | FBINFO_HWACCEL_FILLRECT ; + info->flags = + FBINFO_DEFAULT | FBINFO_READS_FAST | FBINFO_HWACCEL_IMAGEBLIT | + FBINFO_HWACCEL_COPYAREA | FBINFO_HWACCEL_FILLRECT; info->fbops = &dlfb_ops; info->screen_base = rvmalloc(dev_info->screen_size); if (info->screen_base == NULL) { - printk("cannot allocate framebuffer virtual memory of %d bytes\n", dev_info->screen_size); - goto out0 ; + printk + ("cannot allocate framebuffer virtual memory of %d bytes\n", + dev_info->screen_size); + goto out0; } printk("screen base allocated !!!\n"); - //info->var = dev_info->si; + + dev_info->backing_buffer = kzalloc(dev_info->screen_size, GFP_KERNEL); + + if (!dev_info->backing_buffer) + printk("non posso allocare il backing buffer\n"); + + /* info->var = dev_info->si; */ info->var.bits_per_pixel = 16; - info->var.activate = FB_ACTIVATE_TEST ; - info->var.vmode = FB_VMODE_NONINTERLACED; - - info->var.red.offset = 11 ; - info->var.red.length = 5 ; - info->var.red.msb_right = 0 ; - - info->var.green.offset = 5 ; - info->var.green.length = 6 ; - info->var.green.msb_right = 0 ; - - info->var.blue.offset = 0 ; - info->var.blue.length = 5 ; - info->var.blue.msb_right = 0 ; - - //info->var.pixclock = (10000000 / FB_W * 1000 / FB_H)/2 ; - - info->fix.smem_start = (unsigned long) info->screen_base; - info->fix.smem_len = PAGE_ALIGN (dev_info->screen_size) ; - memcpy(info->fix.id,"DisplayLink FB",14); - info->fix.type = FB_TYPE_PACKED_PIXELS ; - info->fix.visual = FB_VISUAL_TRUECOLOR ; - info->fix.accel = info->flags ; - info->fix.line_length = dev_info->line_length ; - - if (fb_alloc_cmap(&info->cmap, 256, 0)<0) { - goto out1 ; - } + info->var.activate = FB_ACTIVATE_TEST; + info->var.vmode = FB_VMODE_NONINTERLACED; + + info->var.red.offset = 11; + info->var.red.length = 5; + info->var.red.msb_right = 0; + + info->var.green.offset = 5; + info->var.green.length = 6; + info->var.green.msb_right = 0; + + info->var.blue.offset = 0; + info->var.blue.length = 5; + info->var.blue.msb_right = 0; + + /* info->var.pixclock = (10000000 / FB_W * 1000 / FB_H)/2 ; */ + + info->fix.smem_start = (unsigned long)info->screen_base; + info->fix.smem_len = PAGE_ALIGN(dev_info->screen_size); + memcpy(info->fix.id, "DisplayLink FB", 14); + info->fix.type = FB_TYPE_PACKED_PIXELS; + info->fix.visual = FB_VISUAL_TRUECOLOR; + info->fix.accel = info->flags; + info->fix.line_length = dev_info->line_length; + + if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) + goto out1; printk("colormap allocated\n"); - if (register_framebuffer(info) < 0){ + if (register_framebuffer(info) < 0) goto out2; - } - draw_rect(dev_info, 0, 0, dev_info->info->var.xres, dev_info->info->var.yres, 0x30, 0xff, 0x30) ; + draw_rect(dev_info, 0, 0, dev_info->info->var.xres, + dev_info->info->var.yres, 0x30, 0xff, 0x30); - return 0 ; + return 0; -out2: + out2: fb_dealloc_cmap(&info->cmap); -out1: + out1: rvfree(info->screen_base, dev_info->screen_size); -out0: + out0: framebuffer_release(info); -out: - usb_set_intfdata (interface, NULL); + out: + usb_set_intfdata(interface, NULL); usb_put_dev(dev_info->udev); kfree(dev_info); return -ENOMEM; - + } static void dlfb_disconnect(struct usb_interface *interface) { - struct dlfb_data *dev_info = usb_get_intfdata (interface); + struct dlfb_data *dev_info = usb_get_intfdata(interface); + + mutex_unlock(&dev_info->bulk_mutex); + + usb_kill_urb(dev_info->tx_urb); + usb_free_urb(dev_info->tx_urb); + usb_set_intfdata(interface, NULL); + usb_put_dev(dev_info->udev); if (dev_info->info) { unregister_framebuffer(dev_info->info); fb_dealloc_cmap(&dev_info->info->cmap); rvfree(dev_info->info->screen_base, dev_info->screen_size); + kfree(dev_info->backing_buffer); framebuffer_release(dev_info->info); + } - usb_set_intfdata(interface, NULL); - usb_put_dev(dev_info->udev); kfree(dev_info); printk("DisplayLink device disconnected\n"); } static struct usb_driver dlfb_driver = { - .name = "udlfb", - .probe = dlfb_probe, - .disconnect = dlfb_disconnect, - .id_table = id_table, + .name = "udlfb", + .probe = dlfb_probe, + .disconnect = dlfb_disconnect, + .id_table = id_table, }; static int __init dlfb_init(void) { int res; - dlfb_init_modes(); @@ -650,7 +907,6 @@ static int __init dlfb_init(void) return res; } - static void __exit dlfb_exit(void) { usb_deregister(&dlfb_driver); diff --git a/recipes/libdlo/kernel-module-udlfb/udlfb.h b/recipes/libdlo/kernel-module-udlfb/udlfb.h new file mode 100644 index 0000000000..f0508628f0 --- /dev/null +++ b/recipes/libdlo/kernel-module-udlfb/udlfb.h @@ -0,0 +1,213 @@ +#define MAX_VMODES 4 +#define FB_BPP 16 + +#define STD_CHANNEL "\x57\xCD\xDC\xA7\x1C\x88\x5E\x15\x60\xFE\xC6\x97\x16\x3D\x47\xF2" + +// as libdlo +#define BUF_HIGH_WATER_MARK 1024 +#define BUF_SIZE 64*1024 + +struct dlfb_data { + struct usb_device *udev; + struct usb_interface *interface; + struct urb *tx_urb, *ctrl_urb; + struct usb_ctrlrequest dr; + struct fb_info *info; + char *buf; + char *bufend; + char *backing_buffer; + struct mutex bulk_mutex; + char edid[128]; + int screen_size; + int line_length; + struct completion done; + int base16; + int base16d; + int base8; + int base8d; +}; + +struct dlfb_video_mode { + + uint8_t col; + uint32_t hclock; + uint32_t vclock; + uint8_t unknown1[6]; + uint16_t xres; + uint8_t unknown2[6]; + uint16_t yres; + uint8_t unknown3[4]; + +} __attribute__ ((__packed__)); + +struct dlfb_video_mode dlfb_video_modes[MAX_VMODES]; + +static void dlfb_bulk_callback(struct urb *urb) +{ + + struct dlfb_data *dev_info = urb->context; + complete(&dev_info->done); + +} + +static int dlfb_bulk_msg(struct dlfb_data *dev_info, int len) +{ + + int ret; + + init_completion(&dev_info->done); + + dev_info->tx_urb->actual_length = 0; + dev_info->tx_urb->transfer_buffer_length = len; + + ret = usb_submit_urb(dev_info->tx_urb, GFP_KERNEL); + if (!wait_for_completion_timeout(&dev_info->done, 1000)) { + usb_kill_urb(dev_info->tx_urb); + printk("usb timeout !!!\n"); + } + + return dev_info->tx_urb->actual_length; + +} + +void dlfb_init_modes(void) +{ + + dlfb_video_modes[0].col = 0; + memcpy(&dlfb_video_modes[0].hclock, "\x20\x3C\x7A\xC9", 4); + memcpy(&dlfb_video_modes[0].vclock, "\xF2\x6C\x48\xF9", 4); + memcpy(&dlfb_video_modes[0].unknown1, "\x70\x53\xFF\xFF\x21\x27", 6); + dlfb_video_modes[0].xres = 800; + memcpy(&dlfb_video_modes[0].unknown2, "\x91\xF3\xFF\xFF\xFF\xF9", 6); + dlfb_video_modes[0].yres = 480; + memcpy(&dlfb_video_modes[0].unknown3, "\x01\x02\xC8\x19", 4); + + dlfb_video_modes[1].col = 0; + memcpy(&dlfb_video_modes[1].hclock, "\x36\x18\xD5\x10", 4); + memcpy(&dlfb_video_modes[1].vclock, "\x60\xA9\x7B\x33", 4); + memcpy(&dlfb_video_modes[1].unknown1, "\xA1\x2B\x27\x32\xFF\xFF", 6); + dlfb_video_modes[1].xres = 1024; + memcpy(&dlfb_video_modes[1].unknown2, "\xD9\x9A\xFF\xCA\xFF\xFF", 6); + dlfb_video_modes[1].yres = 768; + memcpy(&dlfb_video_modes[1].unknown3, "\x04\x03\xC8\x32", 4); + + dlfb_video_modes[2].col = 0; + memcpy(&dlfb_video_modes[2].hclock, "\x98\xF8\x0D\x57", 4); + memcpy(&dlfb_video_modes[2].vclock, "\x2A\x55\x4D\x54", 4); + memcpy(&dlfb_video_modes[2].unknown1, "\xCA\x0D\xFF\xFF\x94\x43", 6); + dlfb_video_modes[2].xres = 1280; + memcpy(&dlfb_video_modes[2].unknown2, "\x9A\xA8\xFF\xFF\xFF\xF9", 6); + dlfb_video_modes[2].yres = 1024; + memcpy(&dlfb_video_modes[2].unknown3, "\x04\x02\x60\x54", 4); + + dlfb_video_modes[3].col = 0; + memcpy(&dlfb_video_modes[3].hclock, "\x42\x24\x38\x36", 4); + memcpy(&dlfb_video_modes[3].vclock, "\xC1\x52\xD9\x29", 4); + memcpy(&dlfb_video_modes[3].unknown1, "\xEA\xB8\x32\x60\xFF\xFF", 6); + dlfb_video_modes[3].xres = 1400; + memcpy(&dlfb_video_modes[3].unknown2, "\xC9\x4E\xFF\xFF\xFF\xF2", 6); + dlfb_video_modes[3].yres = 1050; + memcpy(&dlfb_video_modes[3].unknown3, "\x04\x02\x1E\x5F", 4); + +} + +char *dlfb_set_register(char *bufptr, uint8_t reg, uint8_t val) +{ + + *bufptr++ = 0xAF; + *bufptr++ = 0x20; + *bufptr++ = reg; + *bufptr++ = val; + + return bufptr; + +} + +int dlfb_set_video_mode(struct dlfb_data *dev_info, int width, int height) +{ + + int i, ret; + unsigned char j; + char *bufptr = dev_info->buf; + uint8_t *vdata; + + for (i = 0; i < MAX_VMODES; i++) { + printk("INIT VIDEO %d %d %d\n", i, dlfb_video_modes[i].xres, + dlfb_video_modes[i].yres); + if (dlfb_video_modes[i].xres == width + && dlfb_video_modes[i].yres == height) { + + dev_info->base16 = 0; + dev_info->base16d = width * height * (FB_BPP / 8) ; + + //dev_info->base8 = width * height * (FB_BPP / 8); + + dev_info->base8 = dev_info->base16; + dev_info->base8d = dev_info->base16d; + + // set encryption key (null) + memcpy(dev_info->buf, STD_CHANNEL, 16); + ret = + usb_control_msg(dev_info->udev, + usb_sndctrlpipe(dev_info->udev, 0), + 0x12, (0x02 << 5), 0, 0, + dev_info->buf, 16, 0); + printk("ret control msg 1 (STD_CHANNEL): %d\n", ret); + + // set registers + bufptr = dlfb_set_register(bufptr, 0xFF, 0x00); + + // set color depth + bufptr = dlfb_set_register(bufptr, 0x00, 0x00); + + // set addresses + bufptr = + dlfb_set_register(bufptr, 0x20, + (char)(dev_info->base16 >> 16)); + bufptr = + dlfb_set_register(bufptr, 0x21, + (char)(dev_info->base16 >> 8)); + bufptr = + dlfb_set_register(bufptr, 0x22, + (char)(dev_info->base16)); + + bufptr = + dlfb_set_register(bufptr, 0x26, + (char)(dev_info->base8 >> 16)); + bufptr = + dlfb_set_register(bufptr, 0x27, + (char)(dev_info->base8 >> 8)); + bufptr = + dlfb_set_register(bufptr, 0x28, + (char)(dev_info->base8)); + + // set video mode + vdata = (uint8_t *) & dlfb_video_modes[i]; + for (j = 0; j < 29; j++) { + bufptr = dlfb_set_register(bufptr, j, vdata[j]); + } + + // blank + bufptr = dlfb_set_register(bufptr, 0x1F, 0x00); + + // end registers + bufptr = dlfb_set_register(bufptr, 0xFF, 0xFF); + + // send + ret = dlfb_bulk_msg(dev_info, bufptr - dev_info->buf); + printk("ret bulk 2: %d %d\n", ret, + bufptr - dev_info->buf); + + // flush + ret = dlfb_bulk_msg(dev_info, 0); + printk("ret bulk 3: %d\n", ret); + + dev_info->screen_size = width * height * (FB_BPP / 8); + dev_info->line_length = width * (FB_BPP / 8); + + return 0; + } + } + + return -1; +} -- cgit v1.2.3