// SPDX-License-Identifier: GPL-2.0-only /* * udlfb.c -- Framebuffer driver for DisplayLink USB controller * * Copyright (C) 2009 Roberto De Ioris <[email protected]> * Copyright (C) 2009 Jaya Kumar <[email protected]> * Copyright (C) 2009 Bernie Thompson <[email protected]> * * 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. */ #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> #include <linux/vmalloc.h> #include <linux/slab.h> #include <linux/delay.h> #include <asm/unaligned.h> #include <video/udlfb.h> #include "edid.h" #define OUT_EP_NUM … static const struct fb_fix_screeninfo dlfb_fix = …; static const u32 udlfb_info_flags = …; /* * There are many DisplayLink-based graphics products, all with unique PIDs. * So we match on DisplayLink's VID + Vendor-Defined Interface Class (0xff) * We also require a match on SubClass (0x00) and Protocol (0x00), * which is compatible with all known USB 2.0 era graphics chips and firmware, * but allows DisplayLink to increment those for any future incompatible chips */ static const struct usb_device_id id_table[] = …; MODULE_DEVICE_TABLE(usb, id_table); /* module options */ static bool console = …; /* Allow fbcon to open framebuffer */ static bool fb_defio = …; /* Detect mmap writes using page faults */ static bool shadow = …; /* Optionally disable shadow framebuffer */ static int pixel_limit; /* Optionally force a pixel resolution limit */ struct dlfb_deferred_free { … }; static int dlfb_realloc_framebuffer(struct dlfb_data *dlfb, struct fb_info *info, u32 new_len); /* 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 *dlfb); static int dlfb_submit_urb(struct dlfb_data *dlfb, struct urb * urb, size_t len); static int dlfb_alloc_urb_list(struct dlfb_data *dlfb, int count, size_t size); static void dlfb_free_urb_list(struct dlfb_data *dlfb); /* * All DisplayLink bulk operations start with 0xAF, followed by specific code * All operations are written to buffers which then later get sent to device */ static char *dlfb_set_register(char *buf, u8 reg, u8 val) { … } static char *dlfb_vidreg_lock(char *buf) { … } static char *dlfb_vidreg_unlock(char *buf) { … } /* * Map FB_BLANK_* to DisplayLink register * DLReg FB_BLANK_* * ----- ----------------------------- * 0x00 FB_BLANK_UNBLANK (0) * 0x01 FB_BLANK (1) * 0x03 FB_BLANK_VSYNC_SUSPEND (2) * 0x05 FB_BLANK_HSYNC_SUSPEND (3) * 0x07 FB_BLANK_POWERDOWN (4) Note: requires modeset to come back */ static char *dlfb_blanking(char *buf, int fb_blank) { … } static char *dlfb_set_color_depth(char *buf, u8 selection) { … } static char *dlfb_set_base16bpp(char *wrptr, u32 base) { … } /* * DisplayLink HW has separate 16bpp and 8bpp framebuffers. * In 24bpp modes, the low 323 RGB bits go in the 8bpp framebuffer */ static char *dlfb_set_base8bpp(char *wrptr, u32 base) { … } static char *dlfb_set_register_16(char *wrptr, u8 reg, u16 value) { … } /* * This is kind of weird because the controller takes some * register values in a different byte order than other registers. */ static char *dlfb_set_register_16be(char *wrptr, u8 reg, u16 value) { … } /* * 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. */ static u16 dlfb_lfsr16(u16 actual_count) { … } /* * This does LFSR conversion on the value that is to be written. * See LFSR explanation above for more detail. */ static char *dlfb_set_register_lfsr16(char *wrptr, u8 reg, u16 value) { … } /* * This takes a standard fbdev screeninfo struct and all of its monitor mode * details and converts them into the DisplayLink equivalent register commands. */ static char *dlfb_set_vid_cmds(char *wrptr, struct fb_var_screeninfo *var) { … } /* * 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 *dlfb, struct fb_var_screeninfo *var) { … } static int dlfb_ops_mmap(struct fb_info *info, struct vm_area_struct *vma) { … } /* * 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) { … } /* * 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 * * 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 * compression than 256 pixel raw or rle commands, with similar CPU consumpion. * But for very rl friendly data, will compress not quite as well. */ 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, unsigned long back_buffer_offset, int *ident_ptr) { … } /* * 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. */ static int dlfb_render_hline(struct dlfb_data *dlfb, struct urb **urb_ptr, const char *front, char **urb_buf_ptr, u32 byte_offset, u32 byte_width, int *ident_ptr, int *sent_ptr) { … } static int dlfb_handle_damage(struct dlfb_data *dlfb, int x, int y, int width, int height) { … } static void dlfb_init_damage(struct dlfb_data *dlfb) { … } static void dlfb_damage_work(struct work_struct *w) { … } static void dlfb_offload_damage(struct dlfb_data *dlfb, int x, int y, int width, int height) { … } /* * 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 *pagereflist) { … } static int dlfb_get_edid(struct dlfb_data *dlfb, char *edid, int len) { … } static int dlfb_ops_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg) { … } /* taken from vesafb */ static int dlfb_ops_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue, unsigned transp, struct fb_info *info) { … } /* * It's common for several clients to have framebuffer open simultaneously. * e.g. both fbcon and X. Makes things interesting. * Assumes caller is holding info->lock (for open and release at least) */ static int dlfb_ops_open(struct fb_info *info, int user) { … } static void dlfb_ops_destroy(struct fb_info *info) { … } /* * Assumes caller is holding info->lock mutex (for open and release at least) */ static int dlfb_ops_release(struct fb_info *info, int user) { … } /* * 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 dlfb_data *dlfb) { … } static void dlfb_var_color_format(struct fb_var_screeninfo *var) { … } static int dlfb_ops_check_var(struct fb_var_screeninfo *var, struct fb_info *info) { … } static int dlfb_ops_set_par(struct fb_info *info) { … } /* To fonzi the jukebox (e.g. make blanking changes take effect) */ static char *dlfb_dummy_render(char *buf) { … } /* * In order to come back from full DPMS off, we need to set the mode again */ static int dlfb_ops_blank(int blank_mode, struct fb_info *info) { … } static void dlfb_ops_damage_range(struct fb_info *info, off_t off, size_t len) { … } static void dlfb_ops_damage_area(struct fb_info *info, u32 x, u32 y, u32 width, u32 height) { … } FB_GEN_DEFAULT_DEFERRED_SYSMEM_OPS(dlfb_ops, dlfb_ops_damage_range, dlfb_ops_damage_area) static const struct fb_ops dlfb_ops = …; static void dlfb_deferred_vfree(struct dlfb_data *dlfb, void *mem) { … } /* * Assumes &info->lock held by caller * Assumes no active clients have framebuffer open */ static int dlfb_realloc_framebuffer(struct dlfb_data *dlfb, struct fb_info *info, u32 new_len) { … } /* * 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: * 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 * Returns 0 if successful */ static int dlfb_setup_modes(struct dlfb_data *dlfb, struct fb_info *info, char *default_edid, size_t default_edid_size) { … } static ssize_t metrics_bytes_rendered_show(struct device *fbdev, struct device_attribute *a, char *buf) { … } static ssize_t metrics_bytes_identical_show(struct device *fbdev, struct device_attribute *a, char *buf) { … } static ssize_t metrics_bytes_sent_show(struct device *fbdev, struct device_attribute *a, char *buf) { … } static ssize_t metrics_cpu_kcycles_used_show(struct device *fbdev, struct device_attribute *a, char *buf) { … } static ssize_t edid_show( struct file *filp, struct kobject *kobj, struct bin_attribute *a, char *buf, loff_t off, size_t count) { … } 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) { … } static ssize_t metrics_reset_store(struct device *fbdev, struct device_attribute *attr, const char *buf, size_t count) { … } static const struct bin_attribute edid_attr = …; static const struct device_attribute fb_device_attrs[] = …; /* * This is necessary before we can communicate with the display controller. */ static int dlfb_select_std_channel(struct dlfb_data *dlfb) { … } static int dlfb_parse_vendor_descriptor(struct dlfb_data *dlfb, struct usb_interface *intf) { … } static int dlfb_usb_probe(struct usb_interface *intf, const struct usb_device_id *id) { … } static void dlfb_usb_disconnect(struct usb_interface *intf) { … } static struct usb_driver dlfb_driver = …; module_usb_driver(…) …; static void dlfb_urb_completion(struct urb *urb) { … } static void dlfb_free_urb_list(struct dlfb_data *dlfb) { … } static int dlfb_alloc_urb_list(struct dlfb_data *dlfb, int count, size_t size) { … } static struct urb *dlfb_get_urb(struct dlfb_data *dlfb) { … } static int dlfb_submit_urb(struct dlfb_data *dlfb, struct urb *urb, size_t len) { … } module_param(console, bool, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP); MODULE_PARM_DESC(…) …; module_param(fb_defio, bool, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP); MODULE_PARM_DESC(…) …; module_param(shadow, bool, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP); MODULE_PARM_DESC(…) …; module_param(pixel_limit, int, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP); MODULE_PARM_DESC(…) …; MODULE_AUTHOR(…) …; MODULE_DESCRIPTION(…) …; MODULE_LICENSE(…) …;
Codebase Browser
linux