2009-11-25 00:52:21 +01:00
|
|
|
/*
|
|
|
|
* udlfb.c -- Framebuffer driver for DisplayLink USB controller
|
|
|
|
*
|
|
|
|
* Copyright (C) 2009 Roberto De Ioris <roberto@unbit.it>
|
|
|
|
* Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@gmail.com>
|
2010-02-15 15:46:13 +01:00
|
|
|
* Copyright (C) 2009 Bernie Thompson <bernie@plugable.com>
|
2009-11-25 00:52:21 +01:00
|
|
|
*
|
|
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
|
|
* License v2. See the file COPYING in the main directory of this archive for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* Layout is based on skeletonfb by James Simmons and Geert Uytterhoeven,
|
|
|
|
* usb-skeleton by GregKH.
|
|
|
|
*
|
|
|
|
* Device-specific portions based on information from Displaylink, with work
|
|
|
|
* from Florian Echtler, Henrik Bjerregaard Pedersen, and others.
|
|
|
|
*/
|
2009-06-03 23:03:06 +02:00
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/usb.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/fb.h>
|
2009-07-27 11:01:03 +02:00
|
|
|
#include <linux/vmalloc.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2010-09-06 01:35:19 +02:00
|
|
|
#include <linux/delay.h>
|
|
|
|
|
2009-06-03 23:03:06 +02:00
|
|
|
#include "udlfb.h"
|
|
|
|
|
2009-11-25 00:52:21 +01:00
|
|
|
static struct fb_fix_screeninfo dlfb_fix = {
|
2010-02-15 15:46:13 +01:00
|
|
|
.id = "udlfb",
|
2010-02-15 15:45:43 +01:00
|
|
|
.type = FB_TYPE_PACKED_PIXELS,
|
|
|
|
.visual = FB_VISUAL_TRUECOLOR,
|
|
|
|
.xpanstep = 0,
|
|
|
|
.ypanstep = 0,
|
|
|
|
.ywrapstep = 0,
|
|
|
|
.accel = FB_ACCEL_NONE,
|
2009-11-25 00:52:21 +01:00
|
|
|
};
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
static const u32 udlfb_info_flags = FBINFO_DEFAULT | FBINFO_READS_FAST |
|
|
|
|
#ifdef FBINFO_VIRTFB
|
|
|
|
FBINFO_VIRTFB |
|
|
|
|
#endif
|
|
|
|
FBINFO_HWACCEL_IMAGEBLIT | FBINFO_HWACCEL_FILLRECT |
|
|
|
|
FBINFO_HWACCEL_COPYAREA | FBINFO_MISC_ALWAYS_SETPAR;
|
|
|
|
|
2010-02-15 15:45:49 +01:00
|
|
|
/*
|
|
|
|
* There are many DisplayLink-based products, all with unique PIDs. We are able
|
|
|
|
* to support all volume ones (circa 2009) with a single driver, so we match
|
|
|
|
* globally on VID. TODO: Probe() needs to detect when we might be running
|
|
|
|
* "future" chips, and bail on those, so a compatible driver can match.
|
|
|
|
*/
|
|
|
|
static struct usb_device_id id_table[] = {
|
|
|
|
{.idVendor = 0x17e9, .match_flags = USB_DEVICE_ID_MATCH_VENDOR,},
|
|
|
|
{},
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(usb, id_table);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-09-06 01:35:39 +02:00
|
|
|
/* module options */
|
|
|
|
static int console; /* Optionally allow fbcon to consume first framebuffer */
|
|
|
|
static int fb_defio; /* Optionally enable experimental fb_defio mmap support */
|
2010-02-15 15:46:35 +01:00
|
|
|
|
2010-02-15 15:45:55 +01:00
|
|
|
/* dlfb keeps a list of urbs for efficient bulk transfers */
|
|
|
|
static void dlfb_urb_completion(struct urb *urb);
|
|
|
|
static struct urb *dlfb_get_urb(struct dlfb_data *dev);
|
|
|
|
static int dlfb_submit_urb(struct dlfb_data *dev, struct urb * urb, size_t len);
|
|
|
|
static int dlfb_alloc_urb_list(struct dlfb_data *dev, int count, size_t size);
|
|
|
|
static void dlfb_free_urb_list(struct dlfb_data *dev);
|
|
|
|
|
2009-11-25 00:52:21 +01:00
|
|
|
/*
|
2010-02-15 15:46:48 +01:00
|
|
|
* All DisplayLink bulk operations start with 0xAF, followed by specific code
|
|
|
|
* All operations are written to buffers which then later get sent to device
|
2009-11-25 00:52:21 +01:00
|
|
|
*/
|
2010-02-15 15:46:04 +01:00
|
|
|
static char *dlfb_set_register(char *buf, u8 reg, u8 val)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
2010-02-15 15:45:43 +01:00
|
|
|
*buf++ = 0xAF;
|
|
|
|
*buf++ = 0x20;
|
|
|
|
*buf++ = reg;
|
|
|
|
*buf++ = val;
|
|
|
|
return buf;
|
2009-11-25 00:52:21 +01:00
|
|
|
}
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:04 +01:00
|
|
|
static char *dlfb_vidreg_lock(char *buf)
|
2009-11-25 00:52:21 +01:00
|
|
|
{
|
2010-02-15 15:46:04 +01:00
|
|
|
return dlfb_set_register(buf, 0xFF, 0x00);
|
2009-11-25 00:52:21 +01:00
|
|
|
}
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:04 +01:00
|
|
|
static char *dlfb_vidreg_unlock(char *buf)
|
2009-11-25 00:52:21 +01:00
|
|
|
{
|
2010-02-15 15:46:04 +01:00
|
|
|
return dlfb_set_register(buf, 0xFF, 0xFF);
|
2009-11-25 00:52:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-02-15 15:46:21 +01:00
|
|
|
* On/Off for driving the DisplayLink framebuffer to the display
|
2010-09-06 01:35:10 +02:00
|
|
|
* 0x00 H and V sync on
|
|
|
|
* 0x01 H and V sync off (screen blank but powered)
|
|
|
|
* 0x07 DPMS powerdown (requires modeset to come back)
|
2009-11-25 00:52:21 +01:00
|
|
|
*/
|
2010-02-15 15:46:21 +01:00
|
|
|
static char *dlfb_enable_hvsync(char *buf, bool enable)
|
2009-11-25 00:52:21 +01:00
|
|
|
{
|
2010-02-15 15:46:21 +01:00
|
|
|
if (enable)
|
|
|
|
return dlfb_set_register(buf, 0x1F, 0x00);
|
|
|
|
else
|
2010-09-06 01:35:10 +02:00
|
|
|
return dlfb_set_register(buf, 0x1F, 0x07);
|
2009-11-25 00:52:21 +01:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:04 +01:00
|
|
|
static char *dlfb_set_color_depth(char *buf, u8 selection)
|
2009-11-25 00:52:21 +01:00
|
|
|
{
|
2010-02-15 15:46:04 +01:00
|
|
|
return dlfb_set_register(buf, 0x00, selection);
|
2009-11-25 00:52:21 +01:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:04 +01:00
|
|
|
static char *dlfb_set_base16bpp(char *wrptr, u32 base)
|
2009-11-25 00:52:21 +01:00
|
|
|
{
|
2010-02-15 15:45:43 +01:00
|
|
|
/* the base pointer is 16 bits wide, 0x20 is hi byte. */
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register(wrptr, 0x20, base >> 16);
|
|
|
|
wrptr = dlfb_set_register(wrptr, 0x21, base >> 8);
|
|
|
|
return dlfb_set_register(wrptr, 0x22, base);
|
2009-11-25 00:52:21 +01:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:48 +01:00
|
|
|
/*
|
|
|
|
* DisplayLink HW has separate 16bpp and 8bpp framebuffers.
|
|
|
|
* In 24bpp modes, the low 323 RGB bits go in the 8bpp framebuffer
|
|
|
|
*/
|
2010-02-15 15:46:04 +01:00
|
|
|
static char *dlfb_set_base8bpp(char *wrptr, u32 base)
|
2009-11-25 00:52:21 +01:00
|
|
|
{
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register(wrptr, 0x26, base >> 16);
|
|
|
|
wrptr = dlfb_set_register(wrptr, 0x27, base >> 8);
|
|
|
|
return dlfb_set_register(wrptr, 0x28, base);
|
2009-11-25 00:52:21 +01:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:04 +01:00
|
|
|
static char *dlfb_set_register_16(char *wrptr, u8 reg, u16 value)
|
2009-11-25 00:52:21 +01:00
|
|
|
{
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register(wrptr, reg, value >> 8);
|
|
|
|
return dlfb_set_register(wrptr, reg+1, value);
|
2009-11-25 00:52:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is kind of weird because the controller takes some
|
|
|
|
* register values in a different byte order than other registers.
|
|
|
|
*/
|
2010-02-15 15:46:04 +01:00
|
|
|
static char *dlfb_set_register_16be(char *wrptr, u8 reg, u16 value)
|
2009-11-25 00:52:21 +01:00
|
|
|
{
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register(wrptr, reg, value);
|
|
|
|
return dlfb_set_register(wrptr, reg+1, value >> 8);
|
2009-11-25 00:52:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* LFSR is linear feedback shift register. The reason we have this is
|
|
|
|
* because the display controller needs to minimize the clock depth of
|
|
|
|
* various counters used in the display path. So this code reverses the
|
|
|
|
* provided value into the lfsr16 value by counting backwards to get
|
|
|
|
* the value that needs to be set in the hardware comparator to get the
|
|
|
|
* same actual count. This makes sense once you read above a couple of
|
|
|
|
* times and think about it from a hardware perspective.
|
|
|
|
*/
|
2010-02-15 15:46:48 +01:00
|
|
|
static u16 dlfb_lfsr16(u16 actual_count)
|
2009-11-25 00:52:21 +01:00
|
|
|
{
|
|
|
|
u32 lv = 0xFFFF; /* This is the lfsr value that the hw starts with */
|
|
|
|
|
|
|
|
while (actual_count--) {
|
|
|
|
lv = ((lv << 1) |
|
|
|
|
(((lv >> 15) ^ (lv >> 4) ^ (lv >> 2) ^ (lv >> 1)) & 1))
|
|
|
|
& 0xFFFF;
|
2009-06-03 23:03:06 +02:00
|
|
|
}
|
|
|
|
|
2009-11-25 00:52:21 +01:00
|
|
|
return (u16) lv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This does LFSR conversion on the value that is to be written.
|
|
|
|
* See LFSR explanation above for more detail.
|
|
|
|
*/
|
2010-02-15 15:46:04 +01:00
|
|
|
static char *dlfb_set_register_lfsr16(char *wrptr, u8 reg, u16 value)
|
2009-11-25 00:52:21 +01:00
|
|
|
{
|
2010-02-15 15:46:48 +01:00
|
|
|
return dlfb_set_register_16(wrptr, reg, dlfb_lfsr16(value));
|
2009-06-03 23:03:06 +02:00
|
|
|
}
|
|
|
|
|
2009-11-25 00:52:21 +01:00
|
|
|
/*
|
|
|
|
* This takes a standard fbdev screeninfo struct and all of its monitor mode
|
|
|
|
* details and converts them into the DisplayLink equivalent register commands.
|
|
|
|
*/
|
2010-02-15 15:46:04 +01:00
|
|
|
static char *dlfb_set_vid_cmds(char *wrptr, struct fb_var_screeninfo *var)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
2009-11-25 00:52:21 +01:00
|
|
|
u16 xds, yds;
|
|
|
|
u16 xde, yde;
|
|
|
|
u16 yec;
|
|
|
|
|
|
|
|
/* x display start */
|
|
|
|
xds = var->left_margin + var->hsync_len;
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_lfsr16(wrptr, 0x01, xds);
|
2009-11-25 00:52:21 +01:00
|
|
|
/* x display end */
|
|
|
|
xde = xds + var->xres;
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_lfsr16(wrptr, 0x03, xde);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
/* y display start */
|
|
|
|
yds = var->upper_margin + var->vsync_len;
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_lfsr16(wrptr, 0x05, yds);
|
2009-11-25 00:52:21 +01:00
|
|
|
/* y display end */
|
|
|
|
yde = yds + var->yres;
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_lfsr16(wrptr, 0x07, yde);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
/* x end count is active + blanking - 1 */
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_lfsr16(wrptr, 0x09,
|
|
|
|
xde + var->right_margin - 1);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
/* libdlo hardcodes hsync start to 1 */
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_lfsr16(wrptr, 0x0B, 1);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
/* hsync end is width of sync pulse + 1 */
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_lfsr16(wrptr, 0x0D, var->hsync_len + 1);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
/* hpixels is active pixels */
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_16(wrptr, 0x0F, var->xres);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2009-11-25 00:52:21 +01:00
|
|
|
/* yendcount is vertical active + vertical blanking */
|
|
|
|
yec = var->yres + var->upper_margin + var->lower_margin +
|
|
|
|
var->vsync_len;
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_lfsr16(wrptr, 0x11, yec);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2009-11-25 00:52:21 +01:00
|
|
|
/* libdlo hardcodes vsync start to 0 */
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_lfsr16(wrptr, 0x13, 0);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
/* vsync end is width of vsync pulse */
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_lfsr16(wrptr, 0x15, var->vsync_len);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
/* vpixels is active pixels */
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_16(wrptr, 0x17, var->yres);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
/* convert picoseconds to 5kHz multiple for pclk5k = x * 1E12/5k */
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_register_16be(wrptr, 0x1B,
|
|
|
|
200*1000*1000/var->pixclock);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
return wrptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This takes a standard fbdev screeninfo struct that was fetched or prepared
|
|
|
|
* and then generates the appropriate command sequence that then drives the
|
|
|
|
* display controller.
|
|
|
|
*/
|
|
|
|
static int dlfb_set_video_mode(struct dlfb_data *dev,
|
|
|
|
struct fb_var_screeninfo *var)
|
|
|
|
{
|
|
|
|
char *buf;
|
|
|
|
char *wrptr;
|
|
|
|
int retval = 0;
|
|
|
|
int writesize;
|
2010-02-15 15:46:21 +01:00
|
|
|
struct urb *urb;
|
|
|
|
|
|
|
|
if (!atomic_read(&dev->usb_active))
|
|
|
|
return -EPERM;
|
2009-11-25 00:52:21 +01:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
urb = dlfb_get_urb(dev);
|
|
|
|
if (!urb)
|
|
|
|
return -ENOMEM;
|
2010-09-06 03:29:56 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
buf = (char *) urb->transfer_buffer;
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This first section has to do with setting the base address on the
|
|
|
|
* controller * associated with the display. There are 2 base
|
|
|
|
* pointers, currently, we only * use the 16 bpp segment.
|
|
|
|
*/
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_vidreg_lock(buf);
|
|
|
|
wrptr = dlfb_set_color_depth(wrptr, 0x00);
|
2009-11-25 00:52:21 +01:00
|
|
|
/* set base for 16bpp segment to 0 */
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_base16bpp(wrptr, 0);
|
2009-11-25 00:52:21 +01:00
|
|
|
/* set base for 8bpp segment to end of fb */
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_base8bpp(wrptr, dev->info->fix.smem_len);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_set_vid_cmds(wrptr, var);
|
2010-02-15 15:46:21 +01:00
|
|
|
wrptr = dlfb_enable_hvsync(wrptr, true);
|
2010-02-15 15:46:04 +01:00
|
|
|
wrptr = dlfb_vidreg_unlock(wrptr);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
writesize = wrptr - buf;
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
retval = dlfb_submit_urb(dev, urb, writesize);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:04 +01:00
|
|
|
static int dlfb_ops_mmap(struct fb_info *info, struct vm_area_struct *vma)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2009-06-03 23:47:08 +02:00
|
|
|
if (offset + size > info->fix.smem_len)
|
2009-06-03 23:03:06 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
pos = (unsigned long)info->fix.smem_start + offset;
|
|
|
|
|
2010-09-06 03:29:56 +02:00
|
|
|
dl_notice("mmap() framebuffer addr:%lu size:%lu\n",
|
|
|
|
pos, size);
|
|
|
|
|
2009-06-03 23:03:06 +02:00
|
|
|
while (size > 0) {
|
|
|
|
page = vmalloc_to_pfn((void *)pos);
|
2009-06-03 23:47:08 +02:00
|
|
|
if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
|
2009-06-03 23:03:06 +02:00
|
|
|
return -EAGAIN;
|
2009-06-03 23:47:08 +02:00
|
|
|
|
2009-06-03 23:03:06 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
/*
|
|
|
|
* Trims identical data from front and back of line
|
|
|
|
* Sets new front buffer address and width
|
|
|
|
* And returns byte count of identical pixels
|
|
|
|
* Assumes CPU natural alignment (unsigned long)
|
|
|
|
* for back and front buffer ptrs and width
|
|
|
|
*/
|
|
|
|
static int dlfb_trim_hline(const u8 *bback, const u8 **bfront, int *width_bytes)
|
2009-06-11 08:02:19 +02:00
|
|
|
{
|
2010-02-15 15:46:21 +01:00
|
|
|
int j, k;
|
|
|
|
const unsigned long *back = (const unsigned long *) bback;
|
|
|
|
const unsigned long *front = (const unsigned long *) *bfront;
|
|
|
|
const int width = *width_bytes / sizeof(unsigned long);
|
|
|
|
int identical = width;
|
|
|
|
int start = width;
|
|
|
|
int end = width;
|
|
|
|
|
|
|
|
prefetch((void *) front);
|
|
|
|
prefetch((void *) back);
|
|
|
|
|
|
|
|
for (j = 0; j < width; j++) {
|
|
|
|
if (back[j] != front[j]) {
|
|
|
|
start = j;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-06-11 08:02:19 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
for (k = width - 1; k > j; k--) {
|
|
|
|
if (back[k] != front[k]) {
|
|
|
|
end = k+1;
|
|
|
|
break;
|
|
|
|
}
|
2009-06-11 08:02:19 +02:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
identical = start + (width - end);
|
|
|
|
*bfront = (u8 *) &front[start];
|
|
|
|
*width_bytes = (end - start) * sizeof(unsigned long);
|
|
|
|
|
|
|
|
return identical * sizeof(unsigned long);
|
2009-06-11 08:02:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-04-03 07:00:37 +02:00
|
|
|
* Render a command stream for an encoded horizontal line segment of pixels.
|
|
|
|
*
|
|
|
|
* A command buffer holds several commands.
|
|
|
|
* It always begins with a fresh command header
|
|
|
|
* (the protocol doesn't require this, but we enforce it to allow
|
|
|
|
* multiple buffers to be potentially encoded and sent in parallel).
|
|
|
|
* A single command encodes one contiguous horizontal line of pixels
|
|
|
|
*
|
|
|
|
* The function relies on the client to do all allocation, so that
|
|
|
|
* rendering can be done directly to output buffers (e.g. USB URBs).
|
|
|
|
* The function fills the supplied command buffer, providing information
|
|
|
|
* on where it left off, so the client may call in again with additional
|
|
|
|
* buffers if the line will take several buffers to complete.
|
|
|
|
*
|
|
|
|
* A single command can transmit a maximum of 256 pixels,
|
|
|
|
* regardless of the compression ratio (protocol design limit).
|
|
|
|
* To the hardware, 0 for a size byte means 256
|
2010-09-06 03:29:56 +02:00
|
|
|
*
|
2010-04-03 07:00:37 +02:00
|
|
|
* Rather than 256 pixel commands which are either rl or raw encoded,
|
|
|
|
* the rlx command simply assumes alternating raw and rl spans within one cmd.
|
|
|
|
* This has a slightly larger header overhead, but produces more even results.
|
|
|
|
* It also processes all data (read and write) in a single pass.
|
|
|
|
* Performance benchmarks of common cases show it having just slightly better
|
2010-09-06 03:29:56 +02:00
|
|
|
* compression than 256 pixel raw or rle commands, with similar CPU consumpion.
|
2010-04-03 07:00:37 +02:00
|
|
|
* But for very rl friendly data, will compress not quite as well.
|
|
|
|
*/
|
2010-02-15 15:46:21 +01:00
|
|
|
static void dlfb_compress_hline(
|
|
|
|
const uint16_t **pixel_start_ptr,
|
|
|
|
const uint16_t *const pixel_end,
|
|
|
|
uint32_t *device_address_ptr,
|
|
|
|
uint8_t **command_buffer_ptr,
|
|
|
|
const uint8_t *const cmd_buffer_end)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
2010-02-15 15:46:21 +01:00
|
|
|
const uint16_t *pixel = *pixel_start_ptr;
|
|
|
|
uint32_t dev_addr = *device_address_ptr;
|
|
|
|
uint8_t *cmd = *command_buffer_ptr;
|
|
|
|
const int bpp = 2;
|
|
|
|
|
|
|
|
while ((pixel_end > pixel) &&
|
|
|
|
(cmd_buffer_end - MIN_RLX_CMD_BYTES > cmd)) {
|
|
|
|
uint8_t *raw_pixels_count_byte = 0;
|
|
|
|
uint8_t *cmd_pixels_count_byte = 0;
|
|
|
|
const uint16_t *raw_pixel_start = 0;
|
|
|
|
const uint16_t *cmd_pixel_start, *cmd_pixel_end = 0;
|
|
|
|
|
|
|
|
prefetchw((void *) cmd); /* pull in one cache line at least */
|
|
|
|
|
|
|
|
*cmd++ = 0xAF;
|
|
|
|
*cmd++ = 0x6B;
|
2010-09-06 01:35:27 +02:00
|
|
|
*cmd++ = (uint8_t) ((dev_addr >> 16) & 0xFF);
|
|
|
|
*cmd++ = (uint8_t) ((dev_addr >> 8) & 0xFF);
|
|
|
|
*cmd++ = (uint8_t) ((dev_addr) & 0xFF);
|
2010-02-15 15:46:21 +01:00
|
|
|
|
|
|
|
cmd_pixels_count_byte = cmd++; /* we'll know this later */
|
|
|
|
cmd_pixel_start = pixel;
|
|
|
|
|
|
|
|
raw_pixels_count_byte = cmd++; /* we'll know this later */
|
|
|
|
raw_pixel_start = pixel;
|
|
|
|
|
|
|
|
cmd_pixel_end = pixel + min(MAX_CMD_PIXELS + 1,
|
|
|
|
min((int)(pixel_end - pixel),
|
|
|
|
(int)(cmd_buffer_end - cmd) / bpp));
|
|
|
|
|
|
|
|
prefetch_range((void *) pixel, (cmd_pixel_end - pixel) * bpp);
|
|
|
|
|
|
|
|
while (pixel < cmd_pixel_end) {
|
|
|
|
const uint16_t * const repeating_pixel = pixel;
|
|
|
|
|
|
|
|
*(uint16_t *)cmd = cpu_to_be16p(pixel);
|
|
|
|
cmd += 2;
|
|
|
|
pixel++;
|
|
|
|
|
|
|
|
if (unlikely((pixel < cmd_pixel_end) &&
|
|
|
|
(*pixel == *repeating_pixel))) {
|
|
|
|
/* go back and fill in raw pixel count */
|
|
|
|
*raw_pixels_count_byte = ((repeating_pixel -
|
|
|
|
raw_pixel_start) + 1) & 0xFF;
|
|
|
|
|
|
|
|
while ((pixel < cmd_pixel_end)
|
|
|
|
&& (*pixel == *repeating_pixel)) {
|
|
|
|
pixel++;
|
2009-06-03 23:03:06 +02:00
|
|
|
}
|
2009-11-25 00:52:21 +01:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
/* immediately after raw data is repeat byte */
|
|
|
|
*cmd++ = ((pixel - repeating_pixel) - 1) & 0xFF;
|
2009-11-25 00:52:21 +01:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
/* Then start another raw pixel span */
|
|
|
|
raw_pixel_start = pixel;
|
|
|
|
raw_pixels_count_byte = cmd++;
|
2009-06-11 08:02:19 +02:00
|
|
|
}
|
2009-06-03 23:03:06 +02:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
if (pixel > raw_pixel_start) {
|
|
|
|
/* finalize last RAW span */
|
|
|
|
*raw_pixels_count_byte = (pixel-raw_pixel_start) & 0xFF;
|
|
|
|
}
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
*cmd_pixels_count_byte = (pixel - cmd_pixel_start) & 0xFF;
|
|
|
|
dev_addr += (pixel - cmd_pixel_start) * bpp;
|
2009-06-03 23:03:06 +02:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
if (cmd_buffer_end <= MIN_RLX_CMD_BYTES + cmd) {
|
|
|
|
/* Fill leftover bytes with no-ops */
|
|
|
|
if (cmd_buffer_end > cmd)
|
|
|
|
memset(cmd, 0xAF, cmd_buffer_end - cmd);
|
|
|
|
cmd = (uint8_t *) cmd_buffer_end;
|
2009-06-11 08:02:19 +02:00
|
|
|
}
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
*command_buffer_ptr = cmd;
|
|
|
|
*pixel_start_ptr = pixel;
|
|
|
|
*device_address_ptr = dev_addr;
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
return;
|
2009-06-03 23:03:06 +02:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
/*
|
|
|
|
* There are 3 copies of every pixel: The front buffer that the fbdev
|
|
|
|
* client renders to, the actual framebuffer across the USB bus in hardware
|
|
|
|
* (that we can only write to, slowly, and can never read), and (optionally)
|
|
|
|
* our shadow copy that tracks what's been sent to that hardware buffer.
|
|
|
|
*/
|
2010-09-06 03:28:29 +02:00
|
|
|
static int dlfb_render_hline(struct dlfb_data *dev, struct urb **urb_ptr,
|
2010-02-15 15:46:21 +01:00
|
|
|
const char *front, char **urb_buf_ptr,
|
|
|
|
u32 byte_offset, u32 byte_width,
|
|
|
|
int *ident_ptr, int *sent_ptr)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
2010-02-15 15:46:21 +01:00
|
|
|
const u8 *line_start, *line_end, *next_pixel;
|
|
|
|
u32 dev_addr = dev->base16 + byte_offset;
|
|
|
|
struct urb *urb = *urb_ptr;
|
|
|
|
u8 *cmd = *urb_buf_ptr;
|
|
|
|
u8 *cmd_end = (u8 *) urb->transfer_buffer + urb->transfer_buffer_length;
|
|
|
|
|
|
|
|
line_start = (u8 *) (front + byte_offset);
|
|
|
|
next_pixel = line_start;
|
|
|
|
line_end = next_pixel + byte_width;
|
|
|
|
|
|
|
|
if (dev->backing_buffer) {
|
|
|
|
int offset;
|
|
|
|
const u8 *back_start = (u8 *) (dev->backing_buffer
|
|
|
|
+ byte_offset);
|
|
|
|
|
|
|
|
*ident_ptr += dlfb_trim_hline(back_start, &next_pixel,
|
|
|
|
&byte_width);
|
|
|
|
|
|
|
|
offset = next_pixel - line_start;
|
|
|
|
line_end = next_pixel + byte_width;
|
|
|
|
dev_addr += offset;
|
|
|
|
back_start += offset;
|
|
|
|
line_start += offset;
|
|
|
|
|
|
|
|
memcpy((char *)back_start, (char *) line_start,
|
|
|
|
byte_width);
|
|
|
|
}
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
while (next_pixel < line_end) {
|
|
|
|
|
|
|
|
dlfb_compress_hline((const uint16_t **) &next_pixel,
|
|
|
|
(const uint16_t *) line_end, &dev_addr,
|
|
|
|
(u8 **) &cmd, (u8 *) cmd_end);
|
|
|
|
|
|
|
|
if (cmd >= cmd_end) {
|
|
|
|
int len = cmd - (u8 *) urb->transfer_buffer;
|
|
|
|
if (dlfb_submit_urb(dev, urb, len))
|
2010-09-06 03:28:29 +02:00
|
|
|
return 1; /* lost pixels is set */
|
2010-02-15 15:46:21 +01:00
|
|
|
*sent_ptr += len;
|
|
|
|
urb = dlfb_get_urb(dev);
|
|
|
|
if (!urb)
|
2010-09-06 03:28:29 +02:00
|
|
|
return 1; /* lost_pixels is set */
|
2010-02-15 15:46:21 +01:00
|
|
|
*urb_ptr = urb;
|
|
|
|
cmd = urb->transfer_buffer;
|
|
|
|
cmd_end = &cmd[urb->transfer_buffer_length];
|
2009-06-03 23:03:06 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
*urb_buf_ptr = cmd;
|
2010-09-06 03:28:29 +02:00
|
|
|
|
|
|
|
return 0;
|
2009-06-03 23:03:06 +02:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
int dlfb_handle_damage(struct dlfb_data *dev, int x, int y,
|
|
|
|
int width, int height, char *data)
|
2009-06-11 08:02:19 +02:00
|
|
|
{
|
|
|
|
int i, ret;
|
2010-02-15 15:46:21 +01:00
|
|
|
char *cmd;
|
|
|
|
cycles_t start_cycles, end_cycles;
|
|
|
|
int bytes_sent = 0;
|
|
|
|
int bytes_identical = 0;
|
|
|
|
struct urb *urb;
|
|
|
|
int aligned_x;
|
|
|
|
|
|
|
|
start_cycles = get_cycles();
|
|
|
|
|
|
|
|
aligned_x = DL_ALIGN_DOWN(x, sizeof(unsigned long));
|
|
|
|
width = DL_ALIGN_UP(width + (x-aligned_x), sizeof(unsigned long));
|
|
|
|
x = aligned_x;
|
|
|
|
|
|
|
|
if ((width <= 0) ||
|
|
|
|
(x + width > dev->info->var.xres) ||
|
|
|
|
(y + height > dev->info->var.yres))
|
|
|
|
return -EINVAL;
|
2009-06-11 08:02:19 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
if (!atomic_read(&dev->usb_active))
|
|
|
|
return 0;
|
2009-06-11 08:02:19 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
urb = dlfb_get_urb(dev);
|
|
|
|
if (!urb)
|
|
|
|
return 0;
|
|
|
|
cmd = urb->transfer_buffer;
|
2009-06-11 08:02:19 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
for (i = y; i < y + height ; i++) {
|
|
|
|
const int line_offset = dev->info->fix.line_length * i;
|
|
|
|
const int byte_offset = line_offset + (x * BPP);
|
2009-06-11 08:02:19 +02:00
|
|
|
|
2010-09-06 03:28:29 +02:00
|
|
|
if (dlfb_render_hline(dev, &urb,
|
|
|
|
(char *) dev->info->fix.smem_start,
|
2010-09-06 03:29:56 +02:00
|
|
|
&cmd, byte_offset, width * BPP,
|
2010-09-06 03:28:29 +02:00
|
|
|
&bytes_identical, &bytes_sent))
|
|
|
|
goto error;
|
2009-06-11 08:02:19 +02:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
if (cmd > (char *) urb->transfer_buffer) {
|
|
|
|
/* Send partial buffer remaining before exiting */
|
|
|
|
int len = cmd - (char *) urb->transfer_buffer;
|
|
|
|
ret = dlfb_submit_urb(dev, urb, len);
|
|
|
|
bytes_sent += len;
|
|
|
|
} else
|
|
|
|
dlfb_urb_completion(urb);
|
|
|
|
|
2010-09-06 03:28:29 +02:00
|
|
|
error:
|
2010-02-15 15:46:21 +01:00
|
|
|
atomic_add(bytes_sent, &dev->bytes_sent);
|
|
|
|
atomic_add(bytes_identical, &dev->bytes_identical);
|
|
|
|
atomic_add(width*height*2, &dev->bytes_rendered);
|
|
|
|
end_cycles = get_cycles();
|
|
|
|
atomic_add(((unsigned int) ((end_cycles - start_cycles)
|
|
|
|
>> 10)), /* Kcycles */
|
|
|
|
&dev->cpu_kcycles_used);
|
2009-06-11 08:02:19 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
return 0;
|
2009-06-11 08:02:19 +02:00
|
|
|
}
|
|
|
|
|
2010-09-06 01:35:04 +02:00
|
|
|
static ssize_t dlfb_ops_read(struct fb_info *info, char __user *buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
ssize_t result = -ENOSYS;
|
|
|
|
|
|
|
|
#if defined CONFIG_FB_SYS_FOPS || defined CONFIG_FB_SYS_FOPS_MODULE
|
|
|
|
result = fb_sys_read(info, buf, count, ppos);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Path triggered by usermode clients who write to filesystem
|
|
|
|
* e.g. cat filename > /dev/fb1
|
|
|
|
* Not used by X Windows or text-mode console. But useful for testing.
|
|
|
|
* Slow because of extra copy and we must assume all pixels dirty.
|
|
|
|
*/
|
|
|
|
static ssize_t dlfb_ops_write(struct fb_info *info, const char __user *buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
ssize_t result = -ENOSYS;
|
|
|
|
struct dlfb_data *dev = info->par;
|
|
|
|
u32 offset = (u32) *ppos;
|
|
|
|
|
|
|
|
#if defined CONFIG_FB_SYS_FOPS || defined CONFIG_FB_SYS_FOPS_MODULE
|
|
|
|
|
|
|
|
result = fb_sys_write(info, buf, count, ppos);
|
|
|
|
|
|
|
|
if (result > 0) {
|
|
|
|
int start = max((int)(offset / info->fix.line_length) - 1, 0);
|
|
|
|
int lines = min((u32)((result / info->fix.line_length) + 1),
|
|
|
|
(u32)info->var.yres);
|
|
|
|
|
|
|
|
dlfb_handle_damage(dev, 0, start, info->var.xres,
|
|
|
|
lines, info->screen_base);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
/* hardware has native COPY command (see libdlo), but not worth it for fbcon */
|
|
|
|
static void dlfb_ops_copyarea(struct fb_info *info,
|
|
|
|
const struct fb_copyarea *area)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
struct dlfb_data *dev = info->par;
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
#if defined CONFIG_FB_SYS_COPYAREA || defined CONFIG_FB_SYS_COPYAREA_MODULE
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
sys_copyarea(info, area);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
dlfb_handle_damage(dev, area->dx, area->dy,
|
|
|
|
area->width, area->height, info->screen_base);
|
|
|
|
#endif
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
}
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
static void dlfb_ops_imageblit(struct fb_info *info,
|
|
|
|
const struct fb_image *image)
|
|
|
|
{
|
|
|
|
struct dlfb_data *dev = info->par;
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
#if defined CONFIG_FB_SYS_IMAGEBLIT || defined CONFIG_FB_SYS_IMAGEBLIT_MODULE
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
sys_imageblit(info, image);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
dlfb_handle_damage(dev, image->dx, image->dy,
|
|
|
|
image->width, image->height, info->screen_base);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
#endif
|
2009-06-03 23:03:06 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
static void dlfb_ops_fillrect(struct fb_info *info,
|
|
|
|
const struct fb_fillrect *rect)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
|
|
|
struct dlfb_data *dev = info->par;
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
#if defined CONFIG_FB_SYS_FILLRECT || defined CONFIG_FB_SYS_FILLRECT_MODULE
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
sys_fillrect(info, rect);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
dlfb_handle_damage(dev, rect->dx, rect->dy, rect->width,
|
|
|
|
rect->height, info->screen_base);
|
|
|
|
#endif
|
2009-06-03 23:03:06 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2010-09-06 01:35:39 +02:00
|
|
|
#ifdef CONFIG_FB_DEFERRED_IO
|
|
|
|
/*
|
|
|
|
* NOTE: fb_defio.c is holding info->fbdefio.mutex
|
|
|
|
* Touching ANY framebuffer memory that triggers a page fault
|
|
|
|
* in fb_defio will cause a deadlock, when it also tries to
|
|
|
|
* grab the same mutex.
|
|
|
|
*/
|
|
|
|
static void dlfb_dpy_deferred_io(struct fb_info *info,
|
|
|
|
struct list_head *pagelist)
|
|
|
|
{
|
|
|
|
struct page *cur;
|
|
|
|
struct fb_deferred_io *fbdefio = info->fbdefio;
|
|
|
|
struct dlfb_data *dev = info->par;
|
|
|
|
struct urb *urb;
|
|
|
|
char *cmd;
|
|
|
|
cycles_t start_cycles, end_cycles;
|
|
|
|
int bytes_sent = 0;
|
|
|
|
int bytes_identical = 0;
|
|
|
|
int bytes_rendered = 0;
|
|
|
|
|
|
|
|
if (!fb_defio)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!atomic_read(&dev->usb_active))
|
|
|
|
return;
|
|
|
|
|
|
|
|
start_cycles = get_cycles();
|
|
|
|
|
|
|
|
urb = dlfb_get_urb(dev);
|
|
|
|
if (!urb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
cmd = urb->transfer_buffer;
|
|
|
|
|
|
|
|
/* walk the written page list and render each to device */
|
|
|
|
list_for_each_entry(cur, &fbdefio->pagelist, lru) {
|
|
|
|
|
2010-09-06 03:28:29 +02:00
|
|
|
if (dlfb_render_hline(dev, &urb, (char *) info->fix.smem_start,
|
2010-09-06 01:35:39 +02:00
|
|
|
&cmd, cur->index << PAGE_SHIFT,
|
2010-09-06 03:28:29 +02:00
|
|
|
PAGE_SIZE, &bytes_identical, &bytes_sent))
|
|
|
|
goto error;
|
2010-09-06 01:35:39 +02:00
|
|
|
bytes_rendered += PAGE_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmd > (char *) urb->transfer_buffer) {
|
|
|
|
/* Send partial buffer remaining before exiting */
|
|
|
|
int len = cmd - (char *) urb->transfer_buffer;
|
|
|
|
dlfb_submit_urb(dev, urb, len);
|
|
|
|
bytes_sent += len;
|
|
|
|
} else
|
|
|
|
dlfb_urb_completion(urb);
|
|
|
|
|
2010-09-06 03:28:29 +02:00
|
|
|
error:
|
2010-09-06 01:35:39 +02:00
|
|
|
atomic_add(bytes_sent, &dev->bytes_sent);
|
|
|
|
atomic_add(bytes_identical, &dev->bytes_identical);
|
|
|
|
atomic_add(bytes_rendered, &dev->bytes_rendered);
|
|
|
|
end_cycles = get_cycles();
|
|
|
|
atomic_add(((unsigned int) ((end_cycles - start_cycles)
|
|
|
|
>> 10)), /* Kcycles */
|
|
|
|
&dev->cpu_kcycles_used);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
static int dlfb_get_edid(struct dlfb_data *dev, char *edid, int len)
|
2010-02-15 15:46:08 +01:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int ret;
|
2010-09-06 01:35:23 +02:00
|
|
|
char *rbuf;
|
2010-02-15 15:46:08 +01:00
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
rbuf = kmalloc(2, GFP_KERNEL);
|
|
|
|
if (!rbuf)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
2010-02-15 15:46:08 +01:00
|
|
|
ret = usb_control_msg(dev->udev,
|
|
|
|
usb_rcvctrlpipe(dev->udev, 0), (0x02),
|
|
|
|
(0x80 | (0x02 << 5)), i << 8, 0xA1, rbuf, 2,
|
2010-09-06 01:35:23 +02:00
|
|
|
HZ);
|
|
|
|
if (ret < 1) {
|
|
|
|
dl_err("Read EDID byte %d failed err %x\n", i, ret);
|
|
|
|
i--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
edid[i] = rbuf[1];
|
2010-02-15 15:46:08 +01:00
|
|
|
}
|
2010-09-06 01:35:23 +02:00
|
|
|
|
|
|
|
kfree(rbuf);
|
|
|
|
|
|
|
|
return i;
|
2010-02-15 15:46:08 +01:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:04 +01:00
|
|
|
static int dlfb_ops_ioctl(struct fb_info *info, unsigned int cmd,
|
2010-02-15 15:46:21 +01:00
|
|
|
unsigned long arg)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
2010-02-15 15:46:21 +01:00
|
|
|
|
|
|
|
struct dlfb_data *dev = info->par;
|
2009-06-11 08:02:19 +02:00
|
|
|
struct dloarea *area = NULL;
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
if (!atomic_read(&dev->usb_active))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* TODO: Update X server to get this from sysfs instead */
|
|
|
|
if (cmd == DLFB_IOCTL_RETURN_EDID) {
|
2009-06-11 08:02:19 +02:00
|
|
|
char *edid = (char *)arg;
|
2010-09-06 01:35:23 +02:00
|
|
|
if (copy_to_user(edid, dev->edid, dev->edid_size))
|
2009-06-11 08:02:19 +02:00
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
/* TODO: Help propose a standard fb.h ioctl to report mmap damage */
|
|
|
|
if (cmd == DLFB_IOCTL_REPORT_DAMAGE) {
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-09-06 03:28:29 +02:00
|
|
|
/*
|
|
|
|
* If we have a damage-aware client, turn fb_defio "off"
|
|
|
|
* To avoid perf imact of unecessary page fault handling.
|
|
|
|
* Done by resetting the delay for this fb_info to a very
|
|
|
|
* long period. Pages will become writable and stay that way.
|
|
|
|
* Reset to normal value when all clients have closed this fb.
|
|
|
|
*/
|
|
|
|
if (info->fbdefio)
|
|
|
|
info->fbdefio->delay = DL_DEFIO_WRITE_DISABLE;
|
|
|
|
|
2009-06-03 23:03:06 +02:00
|
|
|
area = (struct dloarea *)arg;
|
|
|
|
|
|
|
|
if (area->x < 0)
|
|
|
|
area->x = 0;
|
|
|
|
|
|
|
|
if (area->x > info->var.xres)
|
|
|
|
area->x = info->var.xres;
|
|
|
|
|
|
|
|
if (area->y < 0)
|
|
|
|
area->y = 0;
|
|
|
|
|
|
|
|
if (area->y > info->var.yres)
|
|
|
|
area->y = info->var.yres;
|
|
|
|
|
2010-02-15 15:46:21 +01:00
|
|
|
dlfb_handle_damage(dev, area->x, area->y, area->w, area->h,
|
2009-06-03 23:03:06 +02:00
|
|
|
info->screen_base);
|
|
|
|
}
|
2009-06-11 08:02:19 +02:00
|
|
|
|
2009-06-03 23:03:06 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-03 23:47:08 +02:00
|
|
|
/* taken from vesafb */
|
2009-06-03 23:03:06 +02:00
|
|
|
static int
|
2010-02-15 15:46:04 +01:00
|
|
|
dlfb_ops_setcolreg(unsigned regno, unsigned red, unsigned green,
|
2009-06-03 23:03:06 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:26 +01:00
|
|
|
/*
|
|
|
|
* It's common for several clients to have framebuffer open simultaneously.
|
|
|
|
* e.g. both fbcon and X. Makes things interesting.
|
2010-09-06 01:35:19 +02:00
|
|
|
* Assumes caller is holding info->lock (for open and release at least)
|
2010-02-15 15:46:26 +01:00
|
|
|
*/
|
|
|
|
static int dlfb_ops_open(struct fb_info *info, int user)
|
|
|
|
{
|
|
|
|
struct dlfb_data *dev = info->par;
|
|
|
|
|
2010-09-06 01:35:39 +02:00
|
|
|
/*
|
|
|
|
* fbcon aggressively connects to first framebuffer it finds,
|
|
|
|
* preventing other clients (X) from working properly. Usually
|
|
|
|
* not what the user wants. Fail by default with option to enable.
|
|
|
|
*/
|
|
|
|
if ((user == 0) & (!console))
|
|
|
|
return -EBUSY;
|
2010-02-15 15:46:26 +01:00
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
/* If the USB device is gone, we don't accept new opens */
|
|
|
|
if (dev->virtualized)
|
|
|
|
return -ENODEV;
|
2010-02-15 15:46:26 +01:00
|
|
|
|
|
|
|
dev->fb_count++;
|
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
kref_get(&dev->kref);
|
|
|
|
|
2010-02-15 15:46:26 +01:00
|
|
|
#ifdef CONFIG_FB_DEFERRED_IO
|
2010-09-06 01:35:39 +02:00
|
|
|
if (fb_defio && (info->fbdefio == NULL)) {
|
2010-09-06 03:28:29 +02:00
|
|
|
/* enable defio at last moment if not disabled by client */
|
|
|
|
|
|
|
|
struct fb_deferred_io *fbdefio;
|
|
|
|
|
|
|
|
fbdefio = kmalloc(GFP_KERNEL, sizeof(struct fb_deferred_io));
|
|
|
|
|
|
|
|
if (fbdefio) {
|
|
|
|
fbdefio->delay = DL_DEFIO_WRITE_DELAY;
|
|
|
|
fbdefio->deferred_io = dlfb_dpy_deferred_io;
|
|
|
|
}
|
|
|
|
|
|
|
|
info->fbdefio = fbdefio;
|
2010-02-15 15:46:26 +01:00
|
|
|
fb_deferred_io_init(info);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
dl_notice("open /dev/fb%d user=%d fb_info=%p count=%d\n",
|
|
|
|
info->node, user, info, dev->fb_count);
|
|
|
|
|
2009-06-03 23:03:06 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:45:55 +01:00
|
|
|
/*
|
|
|
|
* Called when all client interfaces to start transactions have been disabled,
|
|
|
|
* and all references to our device instance (dlfb_data) are released.
|
|
|
|
* Every transaction must have a reference, so we know are fully spun down
|
|
|
|
*/
|
2010-09-06 01:35:19 +02:00
|
|
|
static void dlfb_free(struct kref *kref)
|
2010-02-15 15:45:55 +01:00
|
|
|
{
|
|
|
|
struct dlfb_data *dev = container_of(kref, struct dlfb_data, kref);
|
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
/* this function will wait for all in-flight urbs to complete */
|
|
|
|
if (dev->urbs.count > 0)
|
|
|
|
dlfb_free_urb_list(dev);
|
|
|
|
|
2010-02-15 15:45:55 +01:00
|
|
|
if (dev->backing_buffer)
|
|
|
|
vfree(dev->backing_buffer);
|
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
kfree(dev->edid);
|
|
|
|
|
|
|
|
dl_warn("freeing dlfb_data %p\n", dev);
|
2010-02-15 15:46:26 +01:00
|
|
|
|
2010-02-15 15:45:55 +01:00
|
|
|
kfree(dev);
|
|
|
|
}
|
|
|
|
|
2010-09-06 03:28:29 +02:00
|
|
|
static void dlfb_release_urb_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct urb_node *unode = container_of(work, struct urb_node,
|
|
|
|
release_urb_work.work);
|
|
|
|
|
|
|
|
up(&unode->dev->urbs.limit_sem);
|
|
|
|
}
|
2010-09-06 01:35:19 +02:00
|
|
|
|
|
|
|
static void dlfb_free_framebuffer_work(struct work_struct *work)
|
2010-02-15 15:46:13 +01:00
|
|
|
{
|
2010-09-06 01:35:19 +02:00
|
|
|
struct dlfb_data *dev = container_of(work, struct dlfb_data,
|
|
|
|
free_framebuffer_work.work);
|
|
|
|
struct fb_info *info = dev->info;
|
|
|
|
int node = info->node;
|
|
|
|
|
|
|
|
unregister_framebuffer(info);
|
2010-02-15 15:46:13 +01:00
|
|
|
|
|
|
|
if (info->cmap.len != 0)
|
|
|
|
fb_dealloc_cmap(&info->cmap);
|
|
|
|
if (info->monspecs.modedb)
|
|
|
|
fb_destroy_modedb(info->monspecs.modedb);
|
|
|
|
if (info->screen_base)
|
|
|
|
vfree(info->screen_base);
|
|
|
|
|
|
|
|
fb_destroy_modelist(&info->modelist);
|
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
dev->info = 0;
|
|
|
|
|
|
|
|
/* Assume info structure is freed after this point */
|
2010-02-15 15:46:13 +01:00
|
|
|
framebuffer_release(info);
|
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
dl_warn("fb_info for /dev/fb%d has been freed\n", node);
|
|
|
|
|
|
|
|
/* ref taken in probe() as part of registering framebfufer */
|
|
|
|
kref_put(&dev->kref, dlfb_free);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Assumes caller is holding info->lock mutex (for open and release at least)
|
|
|
|
*/
|
|
|
|
static int dlfb_ops_release(struct fb_info *info, int user)
|
|
|
|
{
|
|
|
|
struct dlfb_data *dev = info->par;
|
|
|
|
|
|
|
|
dev->fb_count--;
|
|
|
|
|
|
|
|
/* We can't free fb_info here - fbmem will touch it when we return */
|
|
|
|
if (dev->virtualized && (dev->fb_count == 0))
|
|
|
|
schedule_delayed_work(&dev->free_framebuffer_work, HZ);
|
|
|
|
|
|
|
|
#ifdef CONFIG_FB_DEFERRED_IO
|
|
|
|
if ((dev->fb_count == 0) && (info->fbdefio)) {
|
|
|
|
fb_deferred_io_cleanup(info);
|
|
|
|
kfree(info->fbdefio);
|
|
|
|
info->fbdefio = NULL;
|
|
|
|
info->fbops->fb_mmap = dlfb_ops_mmap;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
dl_warn("released /dev/fb%d user=%d count=%d\n",
|
|
|
|
info->node, user, dev->fb_count);
|
|
|
|
|
|
|
|
kref_put(&dev->kref, dlfb_free);
|
|
|
|
|
|
|
|
return 0;
|
2010-02-15 15:46:13 +01:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:08 +01:00
|
|
|
/*
|
|
|
|
* Check whether a video mode is supported by the DisplayLink chip
|
|
|
|
* We start from monitor's modes, so don't need to filter that here
|
|
|
|
*/
|
|
|
|
static int dlfb_is_valid_mode(struct fb_videomode *mode,
|
|
|
|
struct fb_info *info)
|
|
|
|
{
|
|
|
|
struct dlfb_data *dev = info->par;
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
if (mode->xres * mode->yres > dev->sku_pixel_limit) {
|
|
|
|
dl_warn("%dx%d beyond chip capabilities\n",
|
|
|
|
mode->xres, mode->yres);
|
2010-02-15 15:46:08 +01:00
|
|
|
return 0;
|
2010-09-06 01:35:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
dl_info("%dx%d valid mode\n", mode->xres, mode->yres);
|
2010-02-15 15:46:08 +01:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dlfb_var_color_format(struct fb_var_screeninfo *var)
|
|
|
|
{
|
|
|
|
const struct fb_bitfield red = { 11, 5, 0 };
|
|
|
|
const struct fb_bitfield green = { 5, 6, 0 };
|
|
|
|
const struct fb_bitfield blue = { 0, 5, 0 };
|
|
|
|
|
|
|
|
var->bits_per_pixel = 16;
|
|
|
|
var->red = red;
|
|
|
|
var->green = green;
|
|
|
|
var->blue = blue;
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
static int dlfb_ops_check_var(struct fb_var_screeninfo *var,
|
|
|
|
struct fb_info *info)
|
|
|
|
{
|
|
|
|
struct fb_videomode mode;
|
|
|
|
|
|
|
|
/* TODO: support dynamically changing framebuffer size */
|
|
|
|
if ((var->xres * var->yres * 2) > info->fix.smem_len)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* set device-specific elements of var unrelated to mode */
|
|
|
|
dlfb_var_color_format(var);
|
|
|
|
|
|
|
|
fb_var_to_videomode(&mode, var);
|
|
|
|
|
|
|
|
if (!dlfb_is_valid_mode(&mode, info))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dlfb_ops_set_par(struct fb_info *info)
|
|
|
|
{
|
|
|
|
struct dlfb_data *dev = info->par;
|
2010-09-06 01:35:23 +02:00
|
|
|
int result;
|
|
|
|
u16 *pix_framebuffer;
|
|
|
|
int i;
|
2010-02-15 15:46:13 +01:00
|
|
|
|
|
|
|
dl_notice("set_par mode %dx%d\n", info->var.xres, info->var.yres);
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
result = dlfb_set_video_mode(dev, &info->var);
|
|
|
|
|
|
|
|
if ((result == 0) && (dev->fb_count == 0)) {
|
|
|
|
|
|
|
|
/* paint greenscreen */
|
|
|
|
|
|
|
|
pix_framebuffer = (u16 *) info->screen_base;
|
|
|
|
for (i = 0; i < info->fix.smem_len / 2; i++)
|
|
|
|
pix_framebuffer[i] = 0x37e6;
|
|
|
|
|
|
|
|
dlfb_handle_damage(dev, 0, 0, info->var.xres, info->var.yres,
|
|
|
|
info->screen_base);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
2010-02-15 15:46:13 +01:00
|
|
|
}
|
|
|
|
|
2010-09-06 01:35:10 +02:00
|
|
|
/*
|
|
|
|
* In order to come back from full DPMS off, we need to set the mode again
|
|
|
|
*/
|
2010-02-15 15:46:04 +01:00
|
|
|
static int dlfb_ops_blank(int blank_mode, struct fb_info *info)
|
2009-06-03 23:47:08 +02:00
|
|
|
{
|
2010-02-15 15:46:21 +01:00
|
|
|
struct dlfb_data *dev = info->par;
|
2009-06-11 08:02:19 +02:00
|
|
|
|
2010-09-06 01:35:10 +02:00
|
|
|
if (blank_mode != FB_BLANK_UNBLANK) {
|
|
|
|
char *bufptr;
|
|
|
|
struct urb *urb;
|
2010-02-15 15:46:21 +01:00
|
|
|
|
2010-09-06 01:35:10 +02:00
|
|
|
urb = dlfb_get_urb(dev);
|
|
|
|
if (!urb)
|
|
|
|
return 0;
|
2010-02-15 15:46:21 +01:00
|
|
|
|
2010-09-06 01:35:10 +02:00
|
|
|
bufptr = (char *) urb->transfer_buffer;
|
|
|
|
bufptr = dlfb_vidreg_lock(bufptr);
|
2010-02-15 15:46:21 +01:00
|
|
|
bufptr = dlfb_enable_hvsync(bufptr, false);
|
2010-09-06 01:35:10 +02:00
|
|
|
bufptr = dlfb_vidreg_unlock(bufptr);
|
|
|
|
|
|
|
|
dlfb_submit_urb(dev, urb, bufptr -
|
|
|
|
(char *) urb->transfer_buffer);
|
2009-06-11 08:02:19 +02:00
|
|
|
} else {
|
2010-09-06 01:35:10 +02:00
|
|
|
dlfb_set_video_mode(dev, &info->var);
|
2009-06-11 08:02:19 +02:00
|
|
|
}
|
|
|
|
|
2009-06-03 23:03:06 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct fb_ops dlfb_ops = {
|
2010-02-15 15:46:13 +01:00
|
|
|
.owner = THIS_MODULE,
|
2010-09-06 01:35:04 +02:00
|
|
|
.fb_read = dlfb_ops_read,
|
|
|
|
.fb_write = dlfb_ops_write,
|
2010-02-15 15:46:04 +01:00
|
|
|
.fb_setcolreg = dlfb_ops_setcolreg,
|
|
|
|
.fb_fillrect = dlfb_ops_fillrect,
|
|
|
|
.fb_copyarea = dlfb_ops_copyarea,
|
|
|
|
.fb_imageblit = dlfb_ops_imageblit,
|
|
|
|
.fb_mmap = dlfb_ops_mmap,
|
|
|
|
.fb_ioctl = dlfb_ops_ioctl,
|
2010-02-15 15:46:26 +01:00
|
|
|
.fb_open = dlfb_ops_open,
|
2010-02-15 15:46:04 +01:00
|
|
|
.fb_release = dlfb_ops_release,
|
|
|
|
.fb_blank = dlfb_ops_blank,
|
2010-02-15 15:46:13 +01:00
|
|
|
.fb_check_var = dlfb_ops_check_var,
|
|
|
|
.fb_set_par = dlfb_ops_set_par,
|
2009-06-03 23:03:06 +02:00
|
|
|
};
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
|
2010-02-15 15:46:08 +01:00
|
|
|
/*
|
2010-09-06 01:35:23 +02:00
|
|
|
* Assumes &info->lock held by caller
|
|
|
|
* Assumes no active clients have framebuffer open
|
|
|
|
*/
|
|
|
|
static int dlfb_realloc_framebuffer(struct dlfb_data *dev, struct fb_info *info)
|
|
|
|
{
|
|
|
|
int retval = -ENOMEM;
|
|
|
|
int old_len = info->fix.smem_len;
|
|
|
|
int new_len;
|
|
|
|
unsigned char *old_fb = info->screen_base;
|
|
|
|
unsigned char *new_fb;
|
|
|
|
unsigned char *new_back;
|
|
|
|
|
|
|
|
dl_warn("Reallocating framebuffer. Addresses will change!\n");
|
|
|
|
|
|
|
|
new_len = info->fix.line_length * info->var.yres;
|
|
|
|
|
|
|
|
if (PAGE_ALIGN(new_len) > old_len) {
|
|
|
|
/*
|
|
|
|
* Alloc system memory for virtual framebuffer
|
|
|
|
*/
|
|
|
|
new_fb = vmalloc(new_len);
|
|
|
|
if (!new_fb) {
|
|
|
|
dl_err("Virtual framebuffer alloc failed\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (info->screen_base) {
|
|
|
|
memcpy(new_fb, old_fb, old_len);
|
|
|
|
vfree(info->screen_base);
|
|
|
|
}
|
|
|
|
|
|
|
|
info->screen_base = new_fb;
|
|
|
|
info->fix.smem_len = PAGE_ALIGN(new_len);
|
|
|
|
info->fix.smem_start = (unsigned long) new_fb;
|
|
|
|
info->flags = udlfb_info_flags;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Second framebuffer copy to mirror the framebuffer state
|
|
|
|
* on the physical USB device. We can function without this.
|
|
|
|
* But with imperfect damage info we may send pixels over USB
|
|
|
|
* that were, in fact, unchanged - wasting limited USB bandwidth
|
|
|
|
*/
|
|
|
|
new_back = vmalloc(new_len);
|
|
|
|
if (!new_back)
|
|
|
|
dl_info("No shadow/backing buffer allcoated\n");
|
|
|
|
else {
|
|
|
|
if (dev->backing_buffer)
|
|
|
|
vfree(dev->backing_buffer);
|
|
|
|
dev->backing_buffer = new_back;
|
|
|
|
memset(dev->backing_buffer, 0, new_len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
retval = 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 1) Get EDID from hw, or use sw default
|
|
|
|
* 2) Parse into various fb_info structs
|
|
|
|
* 3) Allocate virtual framebuffer memory to back highest res mode
|
|
|
|
*
|
|
|
|
* Parses EDID into three places used by various parts of fbdev:
|
2010-02-15 15:46:08 +01:00
|
|
|
* fb_var_screeninfo contains the timing of the monitor's preferred mode
|
|
|
|
* fb_info.monspecs is full parsed EDID info, including monspecs.modedb
|
|
|
|
* fb_info.modelist is a linked list of all monitor & VESA modes which work
|
|
|
|
*
|
|
|
|
* If EDID is not readable/valid, then modelist is all VESA modes,
|
|
|
|
* monspecs is NULL, and fb_var_screeninfo is set to safe VESA mode
|
2010-09-06 01:35:23 +02:00
|
|
|
* Returns 0 if successful
|
2010-02-15 15:46:08 +01:00
|
|
|
*/
|
2010-09-06 01:35:23 +02:00
|
|
|
static int dlfb_setup_modes(struct dlfb_data *dev,
|
|
|
|
struct fb_info *info,
|
|
|
|
char *default_edid, size_t default_edid_size)
|
2010-02-15 15:46:08 +01:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
const struct fb_videomode *default_vmode = NULL;
|
|
|
|
int result = 0;
|
2010-09-06 01:35:23 +02:00
|
|
|
char *edid;
|
|
|
|
int tries = 3;
|
|
|
|
|
|
|
|
if (info->dev) /* only use mutex if info has been registered */
|
|
|
|
mutex_lock(&info->lock);
|
|
|
|
|
|
|
|
edid = kmalloc(MAX_EDID_SIZE, GFP_KERNEL);
|
|
|
|
if (!edid) {
|
|
|
|
result = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
2010-02-15 15:46:08 +01:00
|
|
|
|
|
|
|
fb_destroy_modelist(&info->modelist);
|
|
|
|
memset(&info->monspecs, 0, sizeof(info->monspecs));
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
/*
|
|
|
|
* Try to (re)read EDID from hardware first
|
|
|
|
* EDID data may return, but not parse as valid
|
|
|
|
* Try again a few times, in case of e.g. analog cable noise
|
|
|
|
*/
|
|
|
|
while (tries--) {
|
|
|
|
|
|
|
|
i = dlfb_get_edid(dev, edid, MAX_EDID_SIZE);
|
|
|
|
|
|
|
|
if (i >= MIN_EDID_SIZE)
|
|
|
|
fb_edid_to_monspecs(edid, &info->monspecs);
|
|
|
|
|
|
|
|
if (info->monspecs.modedb_len > 0) {
|
|
|
|
dev->edid = edid;
|
|
|
|
dev->edid_size = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If that fails, use a previously returned EDID if available */
|
|
|
|
if (info->monspecs.modedb_len == 0) {
|
|
|
|
|
|
|
|
dl_err("Unable to get valid EDID from device/display\n");
|
|
|
|
|
|
|
|
if (dev->edid) {
|
|
|
|
fb_edid_to_monspecs(dev->edid, &info->monspecs);
|
|
|
|
if (info->monspecs.modedb_len > 0)
|
|
|
|
dl_err("Using previously queried EDID\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If that fails, use the default EDID we were handed */
|
|
|
|
if (info->monspecs.modedb_len == 0) {
|
|
|
|
if (default_edid_size >= MIN_EDID_SIZE) {
|
|
|
|
fb_edid_to_monspecs(default_edid, &info->monspecs);
|
|
|
|
if (info->monspecs.modedb_len > 0) {
|
|
|
|
memcpy(edid, default_edid, default_edid_size);
|
|
|
|
dev->edid = edid;
|
|
|
|
dev->edid_size = default_edid_size;
|
|
|
|
dl_err("Using default/backup EDID\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-02-15 15:46:08 +01:00
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
/* If we've got modes, let's pick a best default mode */
|
2010-02-15 15:46:08 +01:00
|
|
|
if (info->monspecs.modedb_len > 0) {
|
|
|
|
|
|
|
|
for (i = 0; i < info->monspecs.modedb_len; i++) {
|
|
|
|
if (dlfb_is_valid_mode(&info->monspecs.modedb[i], info))
|
|
|
|
fb_add_videomode(&info->monspecs.modedb[i],
|
|
|
|
&info->modelist);
|
2010-09-06 01:35:23 +02:00
|
|
|
else /* if we've removed top/best mode */
|
|
|
|
info->monspecs.misc &= ~FB_MISC_1ST_DETAIL;
|
2010-02-15 15:46:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
default_vmode = fb_find_best_display(&info->monspecs,
|
|
|
|
&info->modelist);
|
2010-09-06 01:35:23 +02:00
|
|
|
}
|
2010-02-15 15:46:08 +01:00
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
/* If everything else has failed, fall back to safe default mode */
|
|
|
|
if (default_vmode == NULL) {
|
|
|
|
|
|
|
|
struct fb_videomode fb_vmode = {0};
|
2010-02-15 15:46:08 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Add the standard VESA modes to our modelist
|
|
|
|
* Since we don't have EDID, there may be modes that
|
|
|
|
* overspec monitor and/or are incorrect aspect ratio, etc.
|
|
|
|
* But at least the user has a chance to choose
|
|
|
|
*/
|
|
|
|
for (i = 0; i < VESA_MODEDB_SIZE; i++) {
|
|
|
|
if (dlfb_is_valid_mode((struct fb_videomode *)
|
|
|
|
&vesa_modes[i], info))
|
|
|
|
fb_add_videomode(&vesa_modes[i],
|
|
|
|
&info->modelist);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* default to resolution safe for projectors
|
|
|
|
* (since they are most common case without EDID)
|
|
|
|
*/
|
|
|
|
fb_vmode.xres = 800;
|
|
|
|
fb_vmode.yres = 600;
|
|
|
|
fb_vmode.refresh = 60;
|
|
|
|
default_vmode = fb_find_nearest_mode(&fb_vmode,
|
|
|
|
&info->modelist);
|
|
|
|
}
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
/* If we have good mode and no active clients*/
|
|
|
|
if ((default_vmode != NULL) && (dev->fb_count == 0)) {
|
|
|
|
|
|
|
|
fb_videomode_to_var(&info->var, default_vmode);
|
|
|
|
dlfb_var_color_format(&info->var);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* with mode size info, we can now alloc our framebuffer.
|
|
|
|
*/
|
|
|
|
memcpy(&info->fix, &dlfb_fix, sizeof(dlfb_fix));
|
|
|
|
info->fix.line_length = info->var.xres *
|
|
|
|
(info->var.bits_per_pixel / 8);
|
|
|
|
|
|
|
|
result = dlfb_realloc_framebuffer(dev, info);
|
|
|
|
|
|
|
|
} else
|
|
|
|
result = -EINVAL;
|
|
|
|
|
|
|
|
error:
|
|
|
|
if (edid && (dev->edid != edid))
|
|
|
|
kfree(edid);
|
|
|
|
|
|
|
|
if (info->dev)
|
|
|
|
mutex_unlock(&info->lock);
|
2010-02-15 15:46:08 +01:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t metrics_bytes_rendered_show(struct device *fbdev,
|
|
|
|
struct device_attribute *a, char *buf) {
|
|
|
|
struct fb_info *fb_info = dev_get_drvdata(fbdev);
|
|
|
|
struct dlfb_data *dev = fb_info->par;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%u\n",
|
|
|
|
atomic_read(&dev->bytes_rendered));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t metrics_bytes_identical_show(struct device *fbdev,
|
|
|
|
struct device_attribute *a, char *buf) {
|
|
|
|
struct fb_info *fb_info = dev_get_drvdata(fbdev);
|
|
|
|
struct dlfb_data *dev = fb_info->par;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%u\n",
|
|
|
|
atomic_read(&dev->bytes_identical));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t metrics_bytes_sent_show(struct device *fbdev,
|
|
|
|
struct device_attribute *a, char *buf) {
|
|
|
|
struct fb_info *fb_info = dev_get_drvdata(fbdev);
|
|
|
|
struct dlfb_data *dev = fb_info->par;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%u\n",
|
|
|
|
atomic_read(&dev->bytes_sent));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t metrics_cpu_kcycles_used_show(struct device *fbdev,
|
|
|
|
struct device_attribute *a, char *buf) {
|
|
|
|
struct fb_info *fb_info = dev_get_drvdata(fbdev);
|
|
|
|
struct dlfb_data *dev = fb_info->par;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%u\n",
|
|
|
|
atomic_read(&dev->cpu_kcycles_used));
|
|
|
|
}
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
static ssize_t edid_show(
|
|
|
|
struct file *filp,
|
|
|
|
struct kobject *kobj, struct bin_attribute *a,
|
2010-02-15 15:46:08 +01:00
|
|
|
char *buf, loff_t off, size_t count) {
|
|
|
|
struct device *fbdev = container_of(kobj, struct device, kobj);
|
|
|
|
struct fb_info *fb_info = dev_get_drvdata(fbdev);
|
|
|
|
struct dlfb_data *dev = fb_info->par;
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
if (dev->edid == NULL)
|
2010-02-15 15:46:08 +01:00
|
|
|
return 0;
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
if ((off >= dev->edid_size) || (count > dev->edid_size))
|
2010-02-15 15:46:08 +01:00
|
|
|
return 0;
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
if (off + count > dev->edid_size)
|
|
|
|
count = dev->edid_size - off;
|
|
|
|
|
|
|
|
dl_info("sysfs edid copy %p to %p, %d bytes\n",
|
|
|
|
dev->edid, buf, (int) count);
|
|
|
|
|
|
|
|
memcpy(buf, dev->edid, count);
|
2010-02-15 15:46:08 +01:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2010-09-06 01:35:31 +02:00
|
|
|
static ssize_t edid_store(
|
|
|
|
struct file *filp,
|
|
|
|
struct kobject *kobj, struct bin_attribute *a,
|
|
|
|
char *src, loff_t src_off, size_t src_size) {
|
|
|
|
struct device *fbdev = container_of(kobj, struct device, kobj);
|
|
|
|
struct fb_info *fb_info = dev_get_drvdata(fbdev);
|
|
|
|
struct dlfb_data *dev = fb_info->par;
|
|
|
|
|
|
|
|
/* We only support write of entire EDID at once, no offset*/
|
|
|
|
if ((src_size < MIN_EDID_SIZE) ||
|
|
|
|
(src_size > MAX_EDID_SIZE) ||
|
|
|
|
(src_off != 0))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dlfb_setup_modes(dev, fb_info, src, src_size);
|
|
|
|
|
|
|
|
if (dev->edid && (memcmp(src, dev->edid, src_size) == 0)) {
|
|
|
|
dl_info("sysfs written EDID is new default\n");
|
|
|
|
dlfb_ops_set_par(fb_info);
|
|
|
|
return src_size;
|
|
|
|
} else
|
|
|
|
return 0;
|
|
|
|
}
|
2010-02-15 15:46:08 +01:00
|
|
|
|
|
|
|
static ssize_t metrics_reset_store(struct device *fbdev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct fb_info *fb_info = dev_get_drvdata(fbdev);
|
|
|
|
struct dlfb_data *dev = fb_info->par;
|
|
|
|
|
|
|
|
atomic_set(&dev->bytes_rendered, 0);
|
|
|
|
atomic_set(&dev->bytes_identical, 0);
|
|
|
|
atomic_set(&dev->bytes_sent, 0);
|
|
|
|
atomic_set(&dev->cpu_kcycles_used, 0);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct bin_attribute edid_attr = {
|
|
|
|
.attr.name = "edid",
|
2010-09-06 01:35:31 +02:00
|
|
|
.attr.mode = 0666,
|
|
|
|
.size = MAX_EDID_SIZE,
|
2010-02-15 15:46:08 +01:00
|
|
|
.read = edid_show,
|
2010-09-06 01:35:31 +02:00
|
|
|
.write = edid_store
|
2010-02-15 15:46:08 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct device_attribute fb_device_attrs[] = {
|
|
|
|
__ATTR_RO(metrics_bytes_rendered),
|
|
|
|
__ATTR_RO(metrics_bytes_identical),
|
|
|
|
__ATTR_RO(metrics_bytes_sent),
|
|
|
|
__ATTR_RO(metrics_cpu_kcycles_used),
|
|
|
|
__ATTR(metrics_reset, S_IWUGO, NULL, metrics_reset_store),
|
|
|
|
};
|
|
|
|
|
2010-02-15 15:45:49 +01:00
|
|
|
/*
|
|
|
|
* This is necessary before we can communicate with the display controller.
|
|
|
|
*/
|
|
|
|
static int dlfb_select_std_channel(struct dlfb_data *dev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u8 set_def_chn[] = { 0x57, 0xCD, 0xDC, 0xA7,
|
|
|
|
0x1C, 0x88, 0x5E, 0x15,
|
|
|
|
0x60, 0xFE, 0xC6, 0x97,
|
|
|
|
0x16, 0x3D, 0x47, 0xF2 };
|
|
|
|
|
|
|
|
ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
|
|
|
|
NR_USB_REQUEST_CHANNEL,
|
|
|
|
(USB_DIR_OUT | USB_TYPE_VENDOR), 0, 0,
|
|
|
|
set_def_chn, sizeof(set_def_chn), USB_CTRL_SET_TIMEOUT);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
static int dlfb_parse_vendor_descriptor(struct dlfb_data *dev,
|
|
|
|
struct usb_device *usbdev)
|
|
|
|
{
|
|
|
|
char *desc;
|
|
|
|
char *buf;
|
|
|
|
char *desc_end;
|
|
|
|
|
|
|
|
u8 total_len = 0;
|
|
|
|
|
|
|
|
buf = kzalloc(MAX_VENDOR_DESCRIPTOR_SIZE, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return false;
|
|
|
|
desc = buf;
|
|
|
|
|
|
|
|
total_len = usb_get_descriptor(usbdev, 0x5f, /* vendor specific */
|
|
|
|
0, desc, MAX_VENDOR_DESCRIPTOR_SIZE);
|
|
|
|
if (total_len > 5) {
|
|
|
|
dl_info("vendor descriptor length:%x data:%02x %02x %02x %02x" \
|
|
|
|
"%02x %02x %02x %02x %02x %02x %02x\n",
|
|
|
|
total_len, desc[0],
|
|
|
|
desc[1], desc[2], desc[3], desc[4], desc[5], desc[6],
|
|
|
|
desc[7], desc[8], desc[9], desc[10]);
|
|
|
|
|
|
|
|
if ((desc[0] != total_len) || /* descriptor length */
|
|
|
|
(desc[1] != 0x5f) || /* vendor descriptor type */
|
|
|
|
(desc[2] != 0x01) || /* version (2 bytes) */
|
|
|
|
(desc[3] != 0x00) ||
|
|
|
|
(desc[4] != total_len - 2)) /* length after type */
|
|
|
|
goto unrecognized;
|
|
|
|
|
|
|
|
desc_end = desc + total_len;
|
|
|
|
desc += 5; /* the fixed header we've already parsed */
|
|
|
|
|
|
|
|
while (desc < desc_end) {
|
|
|
|
u8 length;
|
|
|
|
u16 key;
|
|
|
|
|
|
|
|
key = *((u16 *) desc);
|
|
|
|
desc += sizeof(u16);
|
|
|
|
length = *desc;
|
|
|
|
desc++;
|
|
|
|
|
|
|
|
switch (key) {
|
|
|
|
case 0x0200: { /* max_area */
|
|
|
|
u32 max_area;
|
|
|
|
max_area = le32_to_cpu(*((u32 *)desc));
|
|
|
|
dl_warn("DL chip limited to %d pixel modes\n",
|
|
|
|
max_area);
|
|
|
|
dev->sku_pixel_limit = max_area;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
desc += length;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
goto success;
|
2010-02-15 15:46:13 +01:00
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
unrecognized:
|
|
|
|
/* allow udlfb to load for now even if firmware unrecognized */
|
|
|
|
dl_err("Unrecognized vendor firmware descriptor\n");
|
|
|
|
|
|
|
|
success:
|
|
|
|
kfree(buf);
|
|
|
|
return true;
|
|
|
|
}
|
2010-02-15 15:46:13 +01:00
|
|
|
static int dlfb_usb_probe(struct usb_interface *interface,
|
2009-11-25 00:52:21 +01:00
|
|
|
const struct usb_device_id *id)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
2009-11-25 00:52:21 +01:00
|
|
|
struct usb_device *usbdev;
|
2010-09-06 01:35:23 +02:00
|
|
|
struct dlfb_data *dev = 0;
|
2010-09-06 01:35:19 +02:00
|
|
|
struct fb_info *info = 0;
|
2009-11-25 00:52:21 +01:00
|
|
|
int retval = -ENOMEM;
|
2010-09-06 03:29:56 +02:00
|
|
|
int i;
|
2009-11-25 00:52:21 +01:00
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
/* usb initialization */
|
|
|
|
|
|
|
|
usbdev = interface_to_usbdev(interface);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
|
|
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
|
|
|
if (dev == NULL) {
|
2010-02-15 15:46:13 +01:00
|
|
|
err("dlfb_usb_probe: failed alloc of dev struct\n");
|
|
|
|
goto error;
|
2009-06-03 23:03:06 +02:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
/* we need to wait for both usb and fbdev to spin down on disconnect */
|
|
|
|
kref_init(&dev->kref); /* matching kref_put in usb .disconnect fn */
|
2010-09-06 01:35:23 +02:00
|
|
|
kref_get(&dev->kref); /* matching kref_put in free_framebuffer_work */
|
2010-02-15 15:46:13 +01:00
|
|
|
|
2009-11-25 00:52:21 +01:00
|
|
|
dev->udev = usbdev;
|
2010-02-15 15:45:55 +01:00
|
|
|
dev->gdev = &usbdev->dev; /* our generic struct device * */
|
2009-11-25 00:52:21 +01:00
|
|
|
usb_set_intfdata(interface, dev);
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
dl_info("%s %s - serial #%s\n",
|
|
|
|
usbdev->manufacturer, usbdev->product, usbdev->serial);
|
|
|
|
dl_info("vid_%04x&pid_%04x&rev_%04x driver's dlfb_data struct at %p\n",
|
|
|
|
usbdev->descriptor.idVendor, usbdev->descriptor.idProduct,
|
|
|
|
usbdev->descriptor.bcdDevice, dev);
|
2010-09-06 01:35:39 +02:00
|
|
|
dl_info("console enable=%d\n", console);
|
|
|
|
dl_info("fb_defio enable=%d\n", fb_defio);
|
2010-09-06 01:35:23 +02:00
|
|
|
|
|
|
|
dev->sku_pixel_limit = 2048 * 1152; /* default to maximum */
|
|
|
|
|
|
|
|
if (!dlfb_parse_vendor_descriptor(dev, usbdev)) {
|
|
|
|
dl_err("firmware not recognized. Assume incompatible device\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
if (!dlfb_alloc_urb_list(dev, WRITES_IN_FLIGHT, MAX_TRANSFER)) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
dl_err("dlfb_alloc_urb_list failed\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We don't register a new USB class. Our client interface is fbdev */
|
2009-11-25 00:52:21 +01:00
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
/* allocates framebuffer driver structure, not framebuffer memory */
|
|
|
|
info = framebuffer_alloc(0, &usbdev->dev);
|
|
|
|
if (!info) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
dl_err("framebuffer_alloc failed\n");
|
|
|
|
goto error;
|
|
|
|
}
|
2010-09-06 01:35:19 +02:00
|
|
|
|
2009-11-25 00:52:21 +01:00
|
|
|
dev->info = info;
|
|
|
|
info->par = dev;
|
|
|
|
info->pseudo_palette = dev->pseudo_palette;
|
2010-02-15 15:46:13 +01:00
|
|
|
info->fbops = &dlfb_ops;
|
2009-11-25 00:52:21 +01:00
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
retval = fb_alloc_cmap(&info->cmap, 256, 0);
|
|
|
|
if (retval < 0) {
|
|
|
|
dl_err("fb_alloc_cmap failed %x\n", retval);
|
|
|
|
goto error;
|
|
|
|
}
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
INIT_DELAYED_WORK(&dev->free_framebuffer_work,
|
|
|
|
dlfb_free_framebuffer_work);
|
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
INIT_LIST_HEAD(&info->modelist);
|
|
|
|
|
|
|
|
retval = dlfb_setup_modes(dev, info, NULL, 0);
|
|
|
|
if (retval != 0) {
|
|
|
|
dl_err("unable to find common mode for display and adapter\n");
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
/* ready to begin using device */
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
atomic_set(&dev->usb_active, 1);
|
|
|
|
dlfb_select_std_channel(dev);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
dlfb_ops_check_var(&info->var, info);
|
2010-02-15 15:46:13 +01:00
|
|
|
dlfb_ops_set_par(info);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
retval = register_framebuffer(info);
|
2009-11-25 00:52:21 +01:00
|
|
|
if (retval < 0) {
|
2010-02-15 15:46:13 +01:00
|
|
|
dl_err("register_framebuffer failed %d\n", retval);
|
|
|
|
goto error;
|
2009-06-11 08:02:19 +02:00
|
|
|
}
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
for (i = 0; i < ARRAY_SIZE(fb_device_attrs); i++)
|
|
|
|
device_create_file(info->dev, &fb_device_attrs[i]);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
device_create_bin_file(info->dev, &edid_attr);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-09-06 01:35:23 +02:00
|
|
|
dl_info("DisplayLink USB device /dev/fb%d attached. %dx%d resolution."
|
2010-02-15 15:46:13 +01:00
|
|
|
" Using %dK framebuffer memory\n", info->node,
|
2010-09-06 01:35:23 +02:00
|
|
|
info->var.xres, info->var.yres,
|
2010-02-15 15:46:13 +01:00
|
|
|
((dev->backing_buffer) ?
|
2010-09-06 01:35:23 +02:00
|
|
|
info->fix.smem_len * 2 : info->fix.smem_len) >> 10);
|
2009-06-03 23:03:06 +02:00
|
|
|
return 0;
|
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
error:
|
|
|
|
if (dev) {
|
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
if (info) {
|
|
|
|
if (info->cmap.len != 0)
|
|
|
|
fb_dealloc_cmap(&info->cmap);
|
|
|
|
if (info->monspecs.modedb)
|
|
|
|
fb_destroy_modedb(info->monspecs.modedb);
|
|
|
|
if (info->screen_base)
|
|
|
|
vfree(info->screen_base);
|
|
|
|
|
|
|
|
fb_destroy_modelist(&info->modelist);
|
|
|
|
|
|
|
|
framebuffer_release(info);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev->backing_buffer)
|
|
|
|
vfree(dev->backing_buffer);
|
|
|
|
|
|
|
|
kref_put(&dev->kref, dlfb_free); /* ref for framebuffer */
|
|
|
|
kref_put(&dev->kref, dlfb_free); /* last ref from kref_init */
|
2010-02-15 15:46:13 +01:00
|
|
|
|
|
|
|
/* dev has been deallocated. Do not dereference */
|
|
|
|
}
|
|
|
|
|
2009-11-25 00:52:21 +01:00
|
|
|
return retval;
|
2009-06-03 23:03:06 +02:00
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
static void dlfb_usb_disconnect(struct usb_interface *interface)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
2009-11-25 00:52:21 +01:00
|
|
|
struct dlfb_data *dev;
|
|
|
|
struct fb_info *info;
|
2010-02-15 15:46:13 +01:00
|
|
|
int i;
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2009-11-25 00:52:21 +01:00
|
|
|
dev = usb_get_intfdata(interface);
|
2010-02-15 15:46:13 +01:00
|
|
|
info = dev->info;
|
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
dl_info("USB disconnect starting\n");
|
2010-02-15 15:46:13 +01:00
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
/* we virtualize until all fb clients release. Then we free */
|
|
|
|
dev->virtualized = true;
|
|
|
|
|
|
|
|
/* When non-active we'll update virtual framebuffer, but no new urbs */
|
|
|
|
atomic_set(&dev->usb_active, 0);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
/* remove udlfb's sysfs interfaces */
|
2010-02-15 15:46:13 +01:00
|
|
|
for (i = 0; i < ARRAY_SIZE(fb_device_attrs); i++)
|
|
|
|
device_remove_file(info->dev, &fb_device_attrs[i]);
|
|
|
|
device_remove_bin_file(info->dev, &edid_attr);
|
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
usb_set_intfdata(interface, NULL);
|
2009-11-25 00:52:21 +01:00
|
|
|
|
2010-09-06 01:35:19 +02:00
|
|
|
/* if clients still have us open, will be freed on last close */
|
|
|
|
if (dev->fb_count == 0)
|
|
|
|
schedule_delayed_work(&dev->free_framebuffer_work, 0);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
/* release reference taken by kref_init in probe() */
|
2010-09-06 01:35:19 +02:00
|
|
|
kref_put(&dev->kref, dlfb_free);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
/* consider dlfb_data freed */
|
|
|
|
|
|
|
|
return;
|
2009-06-03 23:03:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct usb_driver dlfb_driver = {
|
|
|
|
.name = "udlfb",
|
2010-02-15 15:46:13 +01:00
|
|
|
.probe = dlfb_usb_probe,
|
|
|
|
.disconnect = dlfb_usb_disconnect,
|
2009-06-03 23:03:06 +02:00
|
|
|
.id_table = id_table,
|
|
|
|
};
|
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
static int __init dlfb_module_init(void)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
|
|
|
res = usb_register(&dlfb_driver);
|
|
|
|
if (res)
|
|
|
|
err("usb_register failed. Error number %d", res);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
static void __exit dlfb_module_exit(void)
|
2009-06-03 23:03:06 +02:00
|
|
|
{
|
|
|
|
usb_deregister(&dlfb_driver);
|
|
|
|
}
|
|
|
|
|
2010-02-15 15:46:13 +01:00
|
|
|
module_init(dlfb_module_init);
|
|
|
|
module_exit(dlfb_module_exit);
|
2009-06-03 23:03:06 +02:00
|
|
|
|
2010-02-15 15:45:55 +01:00
|
|
|
static void dlfb_urb_completion(struct urb *urb)
|
|
|
|
{
|
|
|
|
struct urb_node *unode = urb->context;
|
|
|
|
struct dlfb_data *dev = unode->dev;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* sync/async unlink faults aren't errors */
|
|
|
|
if (urb->status) {
|
|
|
|
if (!(urb->status == -ENOENT ||
|
|
|
|
urb->status == -ECONNRESET ||
|
|
|
|
urb->status == -ESHUTDOWN)) {
|
|
|
|
dl_err("%s - nonzero write bulk status received: %d\n",
|
|
|
|
__func__, urb->status);
|
|
|
|
atomic_set(&dev->lost_pixels, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
urb->transfer_buffer_length = dev->urbs.size; /* reset to actual */
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->urbs.lock, flags);
|
|
|
|
list_add_tail(&unode->entry, &dev->urbs.list);
|
|
|
|
dev->urbs.available++;
|
|
|
|
spin_unlock_irqrestore(&dev->urbs.lock, flags);
|
|
|
|
|
2010-09-06 03:28:29 +02:00
|
|
|
/*
|
|
|
|
* When using fb_defio, we deadlock if up() is called
|
|
|
|
* while another is waiting. So queue to another process.
|
|
|
|
*/
|
|
|
|
if (fb_defio)
|
|
|
|
schedule_delayed_work(&unode->release_urb_work, 0);
|
|
|
|
else
|
|
|
|
up(&dev->urbs.limit_sem);
|
2010-02-15 15:45:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void dlfb_free_urb_list(struct dlfb_data *dev)
|
|
|
|
{
|
|
|
|
int count = dev->urbs.count;
|
|
|
|
struct list_head *node;
|
|
|
|
struct urb_node *unode;
|
|
|
|
struct urb *urb;
|
|
|
|
int ret;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
dl_notice("Waiting for completes and freeing all render urbs\n");
|
|
|
|
|
|
|
|
/* keep waiting and freeing, until we've got 'em all */
|
|
|
|
while (count--) {
|
2010-09-06 01:35:19 +02:00
|
|
|
|
|
|
|
/* Getting interrupted means a leak, but ok at shutdown*/
|
|
|
|
ret = down_interruptible(&dev->urbs.limit_sem);
|
|
|
|
if (ret)
|
2010-02-15 15:45:55 +01:00
|
|
|
break;
|
2010-09-06 01:35:19 +02:00
|
|
|
|
2010-02-15 15:45:55 +01:00
|
|
|
spin_lock_irqsave(&dev->urbs.lock, flags);
|
|
|
|
|
|
|
|
node = dev->urbs.list.next; /* have reserved one with sem */
|
|
|
|
list_del_init(node);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&dev->urbs.lock, flags);
|
|
|
|
|
|
|
|
unode = list_entry(node, struct urb_node, entry);
|
|
|
|
urb = unode->urb;
|
|
|
|
|
|
|
|
/* Free each separately allocated piece */
|
2010-04-30 00:36:29 +02:00
|
|
|
usb_free_coherent(urb->dev, dev->urbs.size,
|
|
|
|
urb->transfer_buffer, urb->transfer_dma);
|
2010-02-15 15:45:55 +01:00
|
|
|
usb_free_urb(urb);
|
|
|
|
kfree(node);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dlfb_alloc_urb_list(struct dlfb_data *dev, int count, size_t size)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
struct urb *urb;
|
|
|
|
struct urb_node *unode;
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
spin_lock_init(&dev->urbs.lock);
|
|
|
|
|
|
|
|
dev->urbs.size = size;
|
|
|
|
INIT_LIST_HEAD(&dev->urbs.list);
|
|
|
|
|
|
|
|
while (i < count) {
|
|
|
|
unode = kzalloc(sizeof(struct urb_node), GFP_KERNEL);
|
|
|
|
if (!unode)
|
|
|
|
break;
|
|
|
|
unode->dev = dev;
|
|
|
|
|
2010-09-06 03:28:29 +02:00
|
|
|
INIT_DELAYED_WORK(&unode->release_urb_work,
|
|
|
|
dlfb_release_urb_work);
|
|
|
|
|
2010-02-15 15:45:55 +01:00
|
|
|
urb = usb_alloc_urb(0, GFP_KERNEL);
|
|
|
|
if (!urb) {
|
|
|
|
kfree(unode);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
unode->urb = urb;
|
|
|
|
|
2010-04-30 00:36:29 +02:00
|
|
|
buf = usb_alloc_coherent(dev->udev, MAX_TRANSFER, GFP_KERNEL,
|
|
|
|
&urb->transfer_dma);
|
2010-02-15 15:45:55 +01:00
|
|
|
if (!buf) {
|
|
|
|
kfree(unode);
|
|
|
|
usb_free_urb(urb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* urb->transfer_buffer_length set to actual before submit */
|
|
|
|
usb_fill_bulk_urb(urb, dev->udev, usb_sndbulkpipe(dev->udev, 1),
|
|
|
|
buf, size, dlfb_urb_completion, unode);
|
|
|
|
urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
|
|
|
|
|
|
|
|
list_add_tail(&unode->entry, &dev->urbs.list);
|
|
|
|
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
sema_init(&dev->urbs.limit_sem, i);
|
|
|
|
dev->urbs.count = i;
|
|
|
|
dev->urbs.available = i;
|
|
|
|
|
2010-05-14 21:03:00 +02:00
|
|
|
dl_notice("allocated %d %d byte urbs\n", i, (int) size);
|
2010-02-15 15:45:55 +01:00
|
|
|
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct urb *dlfb_get_urb(struct dlfb_data *dev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct list_head *entry;
|
|
|
|
struct urb_node *unode;
|
|
|
|
struct urb *urb = NULL;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* Wait for an in-flight buffer to complete and get re-queued */
|
|
|
|
ret = down_timeout(&dev->urbs.limit_sem, GET_URB_TIMEOUT);
|
|
|
|
if (ret) {
|
|
|
|
atomic_set(&dev->lost_pixels, 1);
|
2010-09-06 03:28:29 +02:00
|
|
|
dl_warn("wait for urb interrupted: %x available: %d\n",
|
|
|
|
ret, dev->urbs.available);
|
2010-02-15 15:45:55 +01:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->urbs.lock, flags);
|
|
|
|
|
|
|
|
BUG_ON(list_empty(&dev->urbs.list)); /* reserved one with limit_sem */
|
|
|
|
entry = dev->urbs.list.next;
|
|
|
|
list_del_init(entry);
|
|
|
|
dev->urbs.available--;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&dev->urbs.lock, flags);
|
|
|
|
|
|
|
|
unode = list_entry(entry, struct urb_node, entry);
|
|
|
|
urb = unode->urb;
|
|
|
|
|
|
|
|
error:
|
|
|
|
return urb;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dlfb_submit_urb(struct dlfb_data *dev, struct urb *urb, size_t len)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
BUG_ON(len > dev->urbs.size);
|
|
|
|
|
|
|
|
urb->transfer_buffer_length = len; /* set to actual payload len */
|
|
|
|
ret = usb_submit_urb(urb, GFP_KERNEL);
|
|
|
|
if (ret) {
|
|
|
|
dlfb_urb_completion(urb); /* because no one else will */
|
|
|
|
atomic_set(&dev->lost_pixels, 1);
|
|
|
|
dl_err("usb_submit_urb error %x\n", ret);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-09-06 01:35:39 +02:00
|
|
|
module_param(console, bool, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP);
|
|
|
|
MODULE_PARM_DESC(console, "Allow fbcon to consume first framebuffer found");
|
|
|
|
|
|
|
|
module_param(fb_defio, bool, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP);
|
|
|
|
MODULE_PARM_DESC(fb_defio, "Enable fb_defio mmap support. *Experimental*");
|
|
|
|
|
2009-11-25 00:52:21 +01:00
|
|
|
MODULE_AUTHOR("Roberto De Ioris <roberto@unbit.it>, "
|
2010-02-15 15:46:13 +01:00
|
|
|
"Jaya Kumar <jayakumar.lkml@gmail.com>, "
|
|
|
|
"Bernie Thompson <bernie@plugable.com>");
|
|
|
|
MODULE_DESCRIPTION("DisplayLink kernel framebuffer driver");
|
2009-06-03 23:03:06 +02:00
|
|
|
MODULE_LICENSE("GPL");
|
2010-02-15 15:46:13 +01:00
|
|
|
|