diff options
| -rw-r--r-- | drivers/staging/udlfb/udlfb.c | 304 | ||||
| -rw-r--r-- | drivers/staging/udlfb/udlfb.h | 3 |
2 files changed, 198 insertions, 109 deletions
diff --git a/drivers/staging/udlfb/udlfb.c b/drivers/staging/udlfb/udlfb.c index 01672df7a24..8ee55c86cff 100644 --- a/drivers/staging/udlfb/udlfb.c +++ b/drivers/staging/udlfb/udlfb.c @@ -3,6 +3,7 @@ * * Copyright (C) 2009 Roberto De Ioris <roberto@unbit.it> * Copyright (C) 2009 Jaya Kumar <jayakumar.lkml@gmail.com> + * Copyright (C) 2009 Bernie Thompson <bernie@plugable.com> * * 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 @@ -27,10 +28,8 @@ #include "udlfb.h" -#define DRIVER_VERSION "DisplayLink Framebuffer Driver 0.4.1" - static struct fb_fix_screeninfo dlfb_fix = { - .id = "displaylinkfb", + .id = "udlfb", .type = FB_TYPE_PACKED_PIXELS, .visual = FB_VISUAL_TRUECOLOR, .xpanstep = 0, @@ -39,6 +38,13 @@ static struct fb_fix_screeninfo dlfb_fix = { .accel = FB_ACCEL_NONE, }; +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; + /* * 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 @@ -940,6 +946,29 @@ static void dlfb_delete(struct kref *kref) } /* + * Called by fbdev as last part of unregister_framebuffer() process + * No new clients can open connections. Deallocate everything fb_info. + */ +static void dlfb_ops_destroy(struct fb_info *info) +{ + struct dlfb_data *dev = info->par; + + 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); + + /* ref taken before register_framebuffer() for dlfb_data clients */ + kref_put(&dev->kref, dlfb_delete); +} + +/* * 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 */ @@ -966,6 +995,35 @@ static void dlfb_var_color_format(struct fb_var_screeninfo *var) var->blue = blue; } +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; + + dl_notice("set_par mode %dx%d\n", info->var.xres, info->var.yres); + + return dlfb_set_video_mode(dev, &info->var); +} + static int dlfb_ops_blank(int blank_mode, struct fb_info *info) { struct dlfb_data *dev_info = info->par; @@ -985,6 +1043,7 @@ static int dlfb_ops_blank(int blank_mode, struct fb_info *info) } static struct fb_ops dlfb_ops = { + .owner = THIS_MODULE, .fb_setcolreg = dlfb_ops_setcolreg, .fb_fillrect = dlfb_ops_fillrect, .fb_copyarea = dlfb_ops_copyarea, @@ -993,6 +1052,8 @@ static struct fb_ops dlfb_ops = { .fb_ioctl = dlfb_ops_ioctl, .fb_release = dlfb_ops_release, .fb_blank = dlfb_ops_blank, + .fb_check_var = dlfb_ops_check_var, + .fb_set_par = dlfb_ops_set_par, }; /* @@ -1222,37 +1283,48 @@ static int dlfb_select_std_channel(struct dlfb_data *dev) return ret; } -static int dlfb_probe(struct usb_interface *interface, + +static int dlfb_usb_probe(struct usb_interface *interface, const struct usb_device_id *id) { - struct device *mydev; struct usb_device *usbdev; struct dlfb_data *dev; struct fb_info *info; int videomemorysize; + int i; unsigned char *videomemory; int retval = -ENOMEM; struct fb_var_screeninfo *var; - struct fb_bitfield red = { 11, 5, 0 }; - struct fb_bitfield green = { 5, 6, 0 }; - struct fb_bitfield blue = { 0, 5, 0 }; + int registered = 0; + u16 *pix_framebuffer; - usbdev = usb_get_dev(interface_to_usbdev(interface)); - mydev = &usbdev->dev; + /* usb initialization */ + + usbdev = interface_to_usbdev(interface); dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (dev == NULL) { - dev_err(mydev, "failed alloc of dev struct\n"); - goto err_devalloc; + err("dlfb_usb_probe: failed alloc of dev struct\n"); + goto error; } + /* 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 */ + kref_get(&dev->kref); /* matching kref_put in .fb_destroy function*/ + mutex_init(&dev->bulk_mutex); + dev->udev = usbdev; dev->gdev = &usbdev->dev; /* our generic struct device * */ - dev->interface = interface; usb_set_intfdata(interface, dev); - dev_info(mydev, "dlfb_probe: setting up DisplayLink device\n"); + if (!dlfb_alloc_urb_list(dev, WRITES_IN_FLIGHT, MAX_TRANSFER)) { + retval = -ENOMEM; + dl_err("dlfb_alloc_urb_list failed\n"); + goto error; + } + + mutex_init(&dev->fb_open_lock); /* * TODO: replace single 64K buffer with buffer list @@ -1260,8 +1332,8 @@ static int dlfb_probe(struct usb_interface *interface, */ dev->buf = kmalloc(BUF_SIZE, GFP_KERNEL); if (dev->buf == NULL) { - dev_err(mydev, "unable to allocate memory for dlfb commands\n"); - goto err_usballoc; + dl_err("unable to allocate memory for dlfb commands\n"); + goto error; } dev->bufend = dev->buf + BUF_SIZE; @@ -1270,49 +1342,51 @@ static int dlfb_probe(struct usb_interface *interface, usb_sndbulkpipe(dev->udev, 1), dev->buf, 0, dlfb_bulk_callback, dev); - /* allocates framebuffer driver structure, not framebuffer memory */ - info = framebuffer_alloc(0, mydev); - if (!info) - goto err_fballoc; + /* We don't register a new USB class. Our client interface is fbdev */ + /* 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; + } dev->info = info; info->par = dev; info->pseudo_palette = dev->pseudo_palette; + info->fbops = &dlfb_ops; var = &info->var; - retval = dlfb_get_var_from_edid(dev, var); - if (retval) { - /* had a problem getting edid. so fallback to 640x480 */ - dev_err(mydev, "Problem %d with EDID.\n", retval); - var->xres = 640; - var->yres = 480; - } + + /* TODO set limit based on actual SKU detection */ + dev->sku_pixel_limit = 2048 * 1152; + + INIT_LIST_HEAD(&info->modelist); + dlfb_parse_edid(dev, var, info); /* * ok, now that we've got the size info, we can alloc our framebuffer. - * We are using 16bpp. */ - info->var.bits_per_pixel = 16; info->fix = dlfb_fix; info->fix.line_length = var->xres * (var->bits_per_pixel / 8); videomemorysize = info->fix.line_length * var->yres; /* * The big chunk of system memory we use as a virtual framebuffer. - * Pages don't need to be set RESERVED (non-swap) immediately on 2.6 - * remap_pfn_page() syscall in our mmap and/or defio will handle. + * TODO: Handle fbcon cursor code calling blit in interrupt context */ videomemory = vmalloc(videomemorysize); - if (!videomemory) - goto err_vidmem; - memset(videomemory, 0, videomemorysize); + if (!videomemory) { + retval = -ENOMEM; + dl_err("Virtual framebuffer alloc failed\n"); + goto error; + } info->screen_base = videomemory; info->fix.smem_len = PAGE_ALIGN(videomemorysize); info->fix.smem_start = (unsigned long) videomemory; - info->flags = - FBINFO_DEFAULT | FBINFO_READS_FAST | FBINFO_HWACCEL_IMAGEBLIT | - FBINFO_HWACCEL_COPYAREA | FBINFO_HWACCEL_FILLRECT; + info->flags = udlfb_info_flags; + /* * Second framebuffer copy, mirroring the state of the framebuffer @@ -1320,109 +1394,121 @@ static int dlfb_probe(struct usb_interface *interface, * But with imperfect damage info we may end up sending pixels over USB * that were, in fact, unchanged -- wasting limited USB bandwidth */ - dev->backing_buffer = vmalloc(dev->screen_size); + dev->backing_buffer = vmalloc(videomemorysize); if (!dev->backing_buffer) - dev_info(mydev, "No backing buffer allocated!\n"); + dl_warn("No shadow/backing buffer allcoated\n"); + else + memset(dev->backing_buffer, 0, videomemorysize); - info->fbops = &dlfb_ops; + retval = fb_alloc_cmap(&info->cmap, 256, 0); + if (retval < 0) { + dl_err("fb_alloc_cmap failed %x\n", retval); + goto error; + } - var->vmode = FB_VMODE_NONINTERLACED; - var->red = red; - var->green = green; - var->blue = blue; + /* ready to begin using device */ - /* - * TODO: Enable FB_CONFIG_DEFIO support +/* +#ifdef CONFIG_FB_DEFERRED_IO + atomic_set(&dev->use_defio, 1); +#endif +*/ + atomic_set(&dev->usb_active, 1); + dlfb_select_std_channel(dev); - info->fbdefio = &dlfb_defio; - fb_deferred_io_init(info); + dlfb_ops_check_var(var, info); + dlfb_ops_set_par(info); - */ + /* paint greenscreen */ +/* + pix_framebuffer = (u16 *) videomemory; + for (i = 0; i < videomemorysize / 2; i++) + pix_framebuffer[i] = 0x37e6; - retval = fb_alloc_cmap(&info->cmap, 256, 0); + dlfb_handle_damage(dev, 0, 0, info->var.xres, info->var.yres, + videomemory); +*/ + retval = register_framebuffer(info); if (retval < 0) { - dev_err(mydev, "Failed to allocate colormap\n"); - goto err_cmap; + dl_err("register_framebuffer failed %d\n", retval); + goto error; } + registered = 1; - dlfb_select_std_channel(dev); - dlfb_set_video_mode(dev, var); - /* TODO: dlfb_dpy_update(dev); */ - - retval = register_framebuffer(info); - if (retval < 0) - goto err_regfb; + for (i = 0; i < ARRAY_SIZE(fb_device_attrs); i++) + device_create_file(info->dev, &fb_device_attrs[i]); - /* paint "successful" green screen */ - draw_rect(dev, 0, 0, dev->info->var.xres, - dev->info->var.yres, 0x30, 0xff, 0x30); + device_create_bin_file(info->dev, &edid_attr); - dev_info(mydev, "DisplayLink USB device %d now attached, " - "using %dK of memory\n", info->node, - ((dev->backing_buffer) ? - videomemorysize * 2 : videomemorysize) >> 10); + dl_err("DisplayLink USB device /dev/fb%d attached. %dx%d resolution." + " Using %dK framebuffer memory\n", info->node, + var->xres, var->yres, + ((dev->backing_buffer) ? + videomemorysize * 2 : videomemorysize) >> 10); return 0; -err_regfb: - fb_dealloc_cmap(&info->cmap); -err_cmap: - /* TODO: fb_deferred_io_cleanup(info); */ - vfree(videomemory); -err_vidmem: - framebuffer_release(info); -err_fballoc: - kfree(dev->buf); -err_usballoc: - usb_set_intfdata(interface, NULL); - usb_put_dev(dev->udev); - kfree(dev); -err_devalloc: +error: + if (dev) { + if (registered) { + unregister_framebuffer(info); + dlfb_ops_destroy(info); + } else + kref_put(&dev->kref, dlfb_delete); + + if (dev->urbs.count > 0) + dlfb_free_urb_list(dev); + kref_put(&dev->kref, dlfb_delete); /* last ref from kref_init */ + + /* dev has been deallocated. Do not dereference */ + } + return retval; } -static void dlfb_disconnect(struct usb_interface *interface) +static void dlfb_usb_disconnect(struct usb_interface *interface) { struct dlfb_data *dev; struct fb_info *info; + int i; dev = usb_get_intfdata(interface); + info = dev->info; + + /* when non-active we'll update virtual framebuffer, but no new urbs */ + atomic_set(&dev->usb_active, 0); + usb_set_intfdata(interface, NULL); - usb_put_dev(dev->udev); - /* - * TODO: since, upon usb disconnect(), usb will cancel in-flight urbs - * and error out any new ones, look at eliminating need for mutex - */ - mutex_lock(&dev->bulk_mutex); - dev->interface = NULL; - info = dev->info; - mutex_unlock(&dev->bulk_mutex); + 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); + + /* this function will wait for all in-flight urbs to complete */ + dlfb_free_urb_list(dev); if (info) { - dev_info(&interface->dev, "Detaching DisplayLink device %d.\n", - info->node); + dl_notice("Detaching /dev/fb%d\n", info->node); unregister_framebuffer(info); - fb_dealloc_cmap(&info->cmap); - /* TODO: fb_deferred_io_cleanup(info); */ - fb_dealloc_cmap(&info->cmap); - vfree((void __force *)info->screen_base); - framebuffer_release(info); + dlfb_ops_destroy(info); } - if (dev->backing_buffer) - vfree(dev->backing_buffer); + /* release reference taken by kref_init in probe() */ + kref_put(&dev->kref, dlfb_delete); - kfree(dev); + /* consider dlfb_data freed */ + + return; } static struct usb_driver dlfb_driver = { .name = "udlfb", - .probe = dlfb_probe, - .disconnect = dlfb_disconnect, + .probe = dlfb_usb_probe, + .disconnect = dlfb_usb_disconnect, .id_table = id_table, }; -static int __init dlfb_init(void) +static int __init dlfb_module_init(void) { int res; @@ -1435,13 +1521,13 @@ static int __init dlfb_init(void) return res; } -static void __exit dlfb_exit(void) +static void __exit dlfb_module_exit(void) { usb_deregister(&dlfb_driver); } -module_init(dlfb_init); -module_exit(dlfb_exit); +module_init(dlfb_module_init); +module_exit(dlfb_module_exit); static void dlfb_urb_completion(struct urb *urb) { @@ -1613,6 +1699,8 @@ static int dlfb_submit_urb(struct dlfb_data *dev, struct urb *urb, size_t len) } MODULE_AUTHOR("Roberto De Ioris <roberto@unbit.it>, " - "Jaya Kumar <jayakumar.lkml@gmail.com>"); -MODULE_DESCRIPTION(DRIVER_VERSION); + "Jaya Kumar <jayakumar.lkml@gmail.com>, " + "Bernie Thompson <bernie@plugable.com>"); +MODULE_DESCRIPTION("DisplayLink kernel framebuffer driver"); MODULE_LICENSE("GPL"); + diff --git a/drivers/staging/udlfb/udlfb.h b/drivers/staging/udlfb/udlfb.h index ef343a6052d..e6c68c65467 100644 --- a/drivers/staging/udlfb/udlfb.h +++ b/drivers/staging/udlfb/udlfb.h @@ -25,13 +25,14 @@ struct dlfb_data { struct device *gdev; /* &udev->dev */ struct usb_interface *interface; struct urb *tx_urb, *ctrl_urb; - struct usb_ctrlrequest dr; struct fb_info *info; struct urb_list urbs; struct kref kref; char *buf; char *bufend; char *backing_buffer; + struct delayed_work deferred_work; + struct mutex fb_open_lock; struct mutex bulk_mutex; int fb_count; atomic_t usb_active; /* 0 = update virtual buffer, but no usb traffic */ |