[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Xen-devel] [PATCH 1/2] Virtual frame buffer: frontend



"Christian Limpach" <christian.limpach@xxxxxxxxx> writes:

> On 6/26/06, Markus Armbruster <armbru@xxxxxxxxxx> wrote:
>> Derived from
>> http://www.cs.utexas.edu/users/aliguori/vfb-20060124.bundle
>>
>> Converted to Xenstore and ported to current kernels.
>
> This looks good.
>
> Could you address the following issues:
>
> - the patch which defined struct xenfb_page seems to be missing

This time it's included.

> - handling of the ring indexes:
>  + we generally prefer to store ring indexes in their unmasked form,
> it makes debugging easier and it allows the ring to be used to its
> full capacity instead of requiring leaving one slot empty to be able
> distinguish empty/full

Done.

>  + unless I misread the code, the producer (for frontend to backend
> messages) seems to write to out_prod + 1 > out_cons, then increment
> out_prob (xenfb_do_update) and then the consumer processes entries
> from out_cons upto but not include the updated out_prod
> (xenfb_on_fb_event) -- the producer for the other way around (backend
> to frontend, xenfb_fb_event) seems to be correcter.

The old code confused me.  I guess my ring index change takes care of
this one, too.

>  + the lack of barriers -- /* FIXME barriers */ doesn't really cut it ;-)
> ==> I would suggest looking at the block or net frontend/backend
> drivers and copy/pasting some code from there...

Found only read barriers in block fe/be.  console has read and write
barriers.  Now I'm confused.  I added read barriers and documented my
confusion.

> - xenbus transactions can fail and there's no code to retry failed 
> transactions

Done.

> Additionally, I think that the dirty region protocol doesn't really
> perform too well in quite simple usage cases like having video play in
> one corner of the screen and the mouse being moved in the opposite
> corner.  It's probably good enough for this version and supporting
> this protocol in the future isn't too bad.

Saved for later.

> I'm looking forward to seeing a new version of this patch, thanks!
>
>    christian

Here you go :)

diff -r d8434a6fdd05 arch/i386/kernel/setup-xen.c
--- a/arch/i386/kernel/setup-xen.c      Fri Jun 16 19:34:13 2006 +0200
+++ b/arch/i386/kernel/setup-xen.c      Mon Jul 10 20:18:50 2006 +0200
@@ -1787,8 +1787,12 @@ void __init setup_arch(char **cmdline_p)
 #endif
 #endif
        } else {
+#if defined(CONFIG_VT) && defined(CONFIG_DUMMY_CONSOLE)
+               conswitchp = &dummy_con;
+#else
                extern int console_use_vt;
                console_use_vt = 0;
+#endif
        }
 }
 
diff -r d8434a6fdd05 drivers/xen/Kconfig
--- a/drivers/xen/Kconfig       Fri Jun 16 19:34:13 2006 +0200
+++ b/drivers/xen/Kconfig       Mon Jul 10 20:18:50 2006 +0200
@@ -173,6 +173,29 @@ config XEN_BLKDEV_TAP
          to a character device, allowing device prototyping in application
          space.  Odds are that you want to say N here.
 
+config XEN_FRAMEBUFFER
+       tristate "Framebuffer-device frontend driver"
+       depends on XEN && FB
+       select FB_CFB_FILLRECT
+       select FB_CFB_COPYAREA
+       select FB_CFB_IMAGEBLIT
+       default y
+       help
+         The framebuffer-device frontend drivers allows the kernel to create a
+         virtual framebuffer.  This framebuffer can be viewed in another
+         domain.  Unless this domain has access to a real video card, you
+         probably want to say Y here.
+
+config XEN_KEYBOARD
+       tristate "Keyboard-device frontend driver"
+       depends on XEN
+       default y
+       help
+         The keyboard-device frontend driver allows the kernel to create a
+         virtual keyboard.  This keyboard can then be driven by another
+         domain.  If you've said Y to CONFIG_XEN_FRAMEBUFFER, you probably
+         want to say Y here.
+
 config XEN_SCRUB_PAGES
        bool "Scrub memory before freeing it to Xen"
        default y
diff -r d8434a6fdd05 drivers/xen/Makefile
--- a/drivers/xen/Makefile      Fri Jun 16 19:34:13 2006 +0200
+++ b/drivers/xen/Makefile      Mon Jul 10 20:18:50 2006 +0200
@@ -15,3 +15,5 @@ obj-$(CONFIG_XEN_BLKDEV_TAP)          += blkt
 obj-$(CONFIG_XEN_BLKDEV_TAP)           += blktap/
 obj-$(CONFIG_XEN_PCIDEV_BACKEND)       += pciback/
 obj-$(CONFIG_XEN_PCIDEV_FRONTEND)      += pcifront/
+obj-$(CONFIG_XEN_FRAMEBUFFER)          += xenfb/
+obj-$(CONFIG_XEN_KEYBOARD)             += xenkbd/
diff -r d8434a6fdd05 drivers/xen/xenfb/Makefile
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/drivers/xen/xenfb/Makefile        Mon Jul 10 20:18:50 2006 +0200
@@ -0,0 +1,1 @@
+obj-$(CONFIG_XEN_FRAMEBUFFER)  := xenfb.o
diff -r d8434a6fdd05 drivers/xen/xenfb/xenfb.c
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/drivers/xen/xenfb/xenfb.c Mon Jul 10 20:18:50 2006 +0200
@@ -0,0 +1,565 @@
+/*
+ * linux/drivers/video/xenfb.c -- Xen para-virtual frame buffer device
+ *
+ * Copyright (C) 2005-2006
+ *
+ *      Anthony Liguori <aliguori@xxxxxxxxxx>
+ *
+ *  Based on linux/drivers/video/q40fb.c
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License. See the file COPYING in the main directory of this archive for
+ *  more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/fb.h>
+#include <linux/module.h>
+#include <linux/vmalloc.h>
+#include <linux/mm.h>
+#include <asm/hypervisor.h>
+#include <xen/evtchn.h>
+#include <xen/xenbus.h>
+#include <linux/xenfb.h>
+#include <linux/kthread.h>
+
+static int xenfb_fps = 20;
+static unsigned long xenfb_mem_len = 2 * 1024 * 1024;
+
+struct xenfb_mapping
+{
+       struct list_head        next;
+       struct vm_area_struct   *vma;
+       atomic_t                map_refs;
+       int                     faults;
+       struct xenfb_info       *info;
+};
+
+struct xenfb_info
+{
+       struct task_struct              *kthread;
+       wait_queue_head_t               wq;
+
+       unsigned char                   *fb;
+       struct fb_fix_screeninfo        *fix;
+       struct fb_var_screeninfo        *var;
+       struct fb_info                  *fb_info;
+       struct timer_list               refresh;
+       int                             dirty;
+       int                             y1, y2;
+       int                             x1, x2;
+
+       struct semaphore                mm_lock;
+       int                             nr_pages;
+       struct page                     **pages;
+       struct list_head                mappings;
+
+       unsigned                        evtchn;
+       struct xenfb_page               *page;
+       unsigned long                   *mfns;
+};
+
+static void xenfb_do_update(struct xenfb_info *info,
+                           int x, int y, int w, int h)
+{
+       union xenfb_out_event event;
+       __u32 prod;
+
+       event.type = XENFB_TYPE_UPDATE;
+       event.update.x = x;
+       event.update.y = y;
+       event.update.width = w;
+       event.update.height = h;
+
+       prod = info->page->out_prod;
+       if (prod - info->page->out_cons == XENFB_RING_SIZE(info->page->out))
+               return;         /* ring buffer full, event lost */
+       XENFB_RING_REF(info->page->out, prod) = event;
+       info->page->out_prod = prod + 1;
+
+       notify_remote_via_evtchn(info->evtchn);
+}
+
+static int xenfb_queue_full(struct xenfb_info *info)
+{
+       __u32 cons, prod;
+
+       prod = info->page->out_prod;
+       cons = info->page->out_cons;
+       return prod - cons == XENFB_RING_SIZE(info->page->out);
+}
+
+static void xenfb_update_screen(struct xenfb_info *info)
+{
+       int y1, y2, x1, x2;
+       struct list_head *item;
+       struct xenfb_mapping *map;
+
+       if (xenfb_queue_full(info))
+               return;
+
+       y1 = info->y1;
+       y2 = info->y2;
+       x1 = info->x1;
+       x2 = info->x2;
+       info->dirty = info->y1 = info->y2 = info->x1 = info->x2 = 0;
+       down(&info->mm_lock);
+       list_for_each(item, &info->mappings) {
+               map = list_entry(item, struct xenfb_mapping, next);
+               if (!map->faults)
+                       continue;
+               zap_page_range(map->vma, map->vma->vm_start,
+                              map->vma->vm_end - map->vma->vm_start, NULL);
+               map->faults = 0;
+       }
+       up(&info->mm_lock);
+
+       xenfb_do_update(info, x1, y1, x2 - x1, y2 - y1);
+}
+
+static int xenfb_thread(void *data)
+{
+       struct xenfb_info *info = data;
+       DECLARE_WAITQUEUE(wait, current);
+
+       add_wait_queue(&info->wq, &wait);
+       for (;;) {
+               if (kthread_should_stop())
+                       break;
+               if (info->dirty)
+                       xenfb_update_screen(info);
+               set_current_state(TASK_INTERRUPTIBLE);
+               schedule();
+       }
+       remove_wait_queue(&info->wq, &wait);
+       return 0;
+}
+
+static int xenfb_setcolreg(unsigned regno, unsigned red, unsigned green,
+                          unsigned blue, unsigned transp,
+                          struct fb_info *info)
+{
+       u32 v;
+
+       if (regno > info->cmap.len)
+               return 1;
+
+       red   >>= (16 - info->var.red.length);
+       green >>= (16 - info->var.green.length);
+       blue  >>= (16 - info->var.blue.length);
+
+       v = (red << info->var.red.offset) |
+           (green << info->var.green.offset) |
+           (blue << info->var.blue.offset);
+
+       switch (info->var.bits_per_pixel) {
+       case 16:
+       case 24:
+       case 32:
+               ((u32 *)info->pseudo_palette)[regno] = v;
+               break;
+       }
+       
+       return 0;
+}
+
+static void xenfb_timer(unsigned long data)
+{
+       struct xenfb_info *info = (struct xenfb_info *)data;
+       info->dirty++;
+       wake_up(&info->wq);
+}
+
+static void xenfb_refresh(struct xenfb_info *info,
+                         int x1, int y1, int w, int h)
+{
+       int y2, x2;
+
+       y2 = y1 + h;
+       x2 = x1 + w;
+       if (info->y2 == 0) {
+               info->y1 = y1;
+               info->y2 = y2;
+       }
+       if (info->x2 == 0) {
+               info->x1 = x1;
+               info->x2 = x2;
+       }
+
+       if (info->y1 > y1)
+               info->y1 = y1;
+       if (info->y2 < y2)
+               info->y2 = y2;
+       if (info->x1 > x1)
+               info->x1 = x1;
+       if (info->x2 < x2)
+               info->x2 = x2;
+
+       if (timer_pending(&info->refresh))
+               return;
+
+       mod_timer(&info->refresh, jiffies + HZ/xenfb_fps);
+}
+
+static void xenfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
+{
+       struct xenfb_info *info = p->par;
+
+       cfb_fillrect(p, rect);
+       xenfb_refresh(info, rect->dx, rect->dy, rect->width, rect->height);
+}
+
+static void xenfb_imageblit(struct fb_info *p, const struct fb_image *image)
+{
+       struct xenfb_info *info = p->par;
+
+       cfb_imageblit(p, image);
+       xenfb_refresh(info, image->dx, image->dy, image->width, image->height);
+}
+
+static void xenfb_copyarea(struct fb_info *p, const struct fb_copyarea *area)
+{
+       struct xenfb_info *info = p->par;
+
+       cfb_copyarea(p, area);
+       xenfb_refresh(info, area->dx, area->dy, area->width, area->height);
+}
+
+static void xenfb_vm_open(struct vm_area_struct *vma)
+{
+       struct xenfb_mapping *map = vma->vm_private_data;
+       atomic_inc(&map->map_refs);
+}
+
+static void xenfb_vm_close(struct vm_area_struct *vma)
+{
+       struct xenfb_mapping *map = vma->vm_private_data;
+       struct xenfb_info *info = map->info;
+
+       down(&info->mm_lock);
+       if (atomic_dec_and_test(&map->map_refs)) {
+               list_del(&map->next);
+               kfree(map);
+       }
+       up(&info->mm_lock);
+}
+
+static struct page *xenfb_vm_nopage(struct vm_area_struct *vma,
+                                   unsigned long vaddr, int *type)
+{
+       struct xenfb_mapping *map = vma->vm_private_data;
+       struct xenfb_info *info = map->info;
+       int pgnr = (vaddr - vma->vm_start) >> PAGE_SHIFT;
+       struct page *page;
+       int y1, y2;
+
+       if (pgnr >= info->nr_pages)
+               return NOPAGE_SIGBUS;
+
+       down(&info->mm_lock);
+       page = info->pages[pgnr];
+       get_page(page);
+       map->faults++;
+
+       y1 = pgnr * PAGE_SIZE / info->fix->line_length;
+       y2 = (pgnr * PAGE_SIZE + PAGE_SIZE - 1) / info->fix->line_length;
+       if (y2 > info->var->yres)
+               y2 = info->var->yres;
+       xenfb_refresh(info, 0, y1, info->var->xres, y2 - y1);
+       up(&info->mm_lock);
+
+       if (type)
+               *type = VM_FAULT_MINOR;
+
+       return page;
+}
+
+static struct vm_operations_struct xenfb_vm_ops = {
+       .open   = xenfb_vm_open,
+       .close  = xenfb_vm_close,
+       .nopage = xenfb_vm_nopage,
+};
+
+static int xenfb_mmap(struct fb_info *fb_info, struct vm_area_struct *vma)
+{
+       struct xenfb_info *info = fb_info->par;
+       struct xenfb_mapping *map;
+       int ret;
+       int map_pages;
+
+       down(&info->mm_lock);
+
+       ret = -EINVAL;
+       if (!(vma->vm_flags & VM_WRITE))
+               goto out;
+       if (!(vma->vm_flags & VM_SHARED))
+               goto out;
+       if (vma->vm_pgoff != 0)
+               goto out;
+
+       map_pages = (vma->vm_end - vma->vm_start + PAGE_SIZE-1) >> PAGE_SHIFT;
+       if (map_pages > info->nr_pages)
+               goto out;
+
+       ret = -ENOMEM;
+       map = kmalloc(sizeof(*map), GFP_KERNEL);
+       if (map == NULL)
+               goto out;
+       memset(map, 0, sizeof(*map));
+
+       map->vma = vma;
+       map->faults = 0;
+       map->info = info;
+       atomic_set(&map->map_refs, 1);
+       list_add(&map->next, &info->mappings);
+       vma->vm_ops = &xenfb_vm_ops;
+       vma->vm_flags |= (VM_DONTEXPAND | VM_RESERVED);
+       vma->vm_private_data = map;
+       ret = 0;
+
+ out:
+       up(&info->mm_lock);
+       return ret;
+}
+
+static struct fb_ops xenfb_fb_ops = {
+       .owner          = THIS_MODULE,
+       .fb_setcolreg   = xenfb_setcolreg,
+       .fb_fillrect    = xenfb_fillrect,
+       .fb_copyarea    = xenfb_copyarea,
+       .fb_imageblit   = xenfb_imageblit,
+       .fb_mmap        = xenfb_mmap,
+};
+
+static irqreturn_t xenfb_event_handler(int rq, void *dev_id,
+                                      struct pt_regs *regs)
+{
+       struct xenfb_info *info = dev_id;
+       __u32 cons, prod;
+
+       if (!info->page || !info->page->initialized)
+               return IRQ_NONE;
+
+       prod = info->page->in_prod;
+       rmb();                  /* ensure we see ring contents up to prod */
+       for (cons = info->page->in_cons; cons != prod; cons++) {
+               union xenfb_in_event *event;
+               event = &XENFB_RING_REF(info->page->in, cons);
+               notify_remote_via_evtchn(info->evtchn);
+       }
+       /* FIXME do I need a wmb() here? */
+       info->page->in_cons = cons;
+
+       return IRQ_HANDLED;
+}
+
+static unsigned long vmalloc_to_mfn(void *address)
+{
+       return pfn_to_mfn(vmalloc_to_pfn(address));
+}
+
+static struct xenfb_info *xenfb_info;
+static int xenfb_irq;
+
+static int __init xenfb_probe(void)
+{
+       struct xenfb_info *info;
+       int i, ret;
+       struct fb_info *fb_info;
+       struct evtchn_alloc_unbound alloc_unbound;
+       xenbus_transaction_t xbt;
+
+       info = kmalloc(sizeof(*info), GFP_KERNEL);
+       if (info == NULL)
+               return -ENOMEM;
+       memset(info, 0, sizeof(*info));
+
+       INIT_LIST_HEAD(&info->mappings);
+
+       info->fb = vmalloc(xenfb_mem_len);
+       if (info->fb == NULL)
+               goto error;
+       memset(info->fb, 0, xenfb_mem_len);
+       info->nr_pages = (xenfb_mem_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+       info->pages = kmalloc(sizeof(struct page*)*info->nr_pages, GFP_KERNEL);
+       if (info->pages == NULL)
+               goto error_vfree;
+       for (i = 0; i < info->nr_pages; i++)
+               info->pages[i] = vmalloc_to_page(info->fb + i * PAGE_SIZE);
+
+       fb_info = framebuffer_alloc(sizeof(u32) * 256, NULL);
+       if (fb_info == NULL)
+               goto error_kfree;
+
+       info->mfns = vmalloc(sizeof(unsigned long) * info->nr_pages);
+       /* set up shared page */
+       info->page = (void *)__get_free_page(GFP_KERNEL);
+       if (!info->page)
+               goto error_kfree;
+       /* set up event channel */
+       alloc_unbound.dom = DOMID_SELF;
+       alloc_unbound.remote_dom = 0;
+       ret = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
+                                         &alloc_unbound);
+       if (ret)
+               goto error_freep;
+       info->evtchn = alloc_unbound.port;
+
+       for (i = 0; i < info->nr_pages; i++)
+               info->mfns[i] = vmalloc_to_mfn(info->fb + i * PAGE_SIZE);
+       info->page->pd[0] = vmalloc_to_mfn(info->mfns);
+       info->page->width = 800;
+       info->page->height = 600;
+       info->page->depth = 32;
+       info->page->line_length = (info->page->depth / 8) * info->page->width;
+       info->page->mem_length = xenfb_mem_len;
+
+       ret = bind_evtchn_to_irqhandler(info->evtchn, xenfb_event_handler,
+                                       0, "xenfb", info);
+       if (ret < 0)
+               // FIXME need to close evtchn?
+               goto error_kfree;
+
+       xenfb_irq = ret;
+       xenfb_info = info;
+
+       fb_info->pseudo_palette = fb_info->par;
+       fb_info->par = info;
+       fb_info->screen_base = info->fb;
+
+       memset(&fb_info->var, 0, sizeof(fb_info->var));
+       memset(&fb_info->fix, 0, sizeof(fb_info->fix));
+
+       fb_info->fbops = &xenfb_fb_ops;
+       fb_info->var.xres_virtual = fb_info->var.xres = info->page->width;
+       fb_info->var.yres_virtual = fb_info->var.yres = info->page->height;
+       fb_info->var.bits_per_pixel = info->page->depth;
+
+       fb_info->var.red = (struct fb_bitfield){16, 8, 0};
+       fb_info->var.green = (struct fb_bitfield){8, 8, 0};
+       fb_info->var.blue = (struct fb_bitfield){0, 8, 0};
+
+       fb_info->var.activate = FB_ACTIVATE_NOW;
+       fb_info->var.height = -1;
+       fb_info->var.width = -1;
+       fb_info->var.vmode = FB_VMODE_NONINTERLACED;
+
+       fb_info->fix.visual = FB_VISUAL_TRUECOLOR;
+       fb_info->fix.line_length = info->page->line_length;
+       fb_info->fix.smem_start = 0;
+       fb_info->fix.smem_len = xenfb_mem_len;
+       strcpy(fb_info->fix.id, "xen");
+       fb_info->fix.type = FB_TYPE_PACKED_PIXELS;
+       fb_info->fix.accel = FB_ACCEL_NONE;
+
+       fb_info->flags = FBINFO_FLAG_DEFAULT;
+
+       fb_alloc_cmap(&fb_info->cmap, 256, 0);
+
+       info->fb_info = fb_info;
+       info->fix = &fb_info->fix;
+       info->var = &fb_info->var;
+
+       init_MUTEX(&info->mm_lock);
+       init_waitqueue_head(&info->wq);
+       init_timer(&info->refresh);
+       info->refresh.function = xenfb_timer;
+       info->refresh.data = (unsigned long)info;
+
+       info->kthread = kthread_run(xenfb_thread, info, "xenfb thread");
+
+       ret = register_framebuffer(fb_info);
+       if (ret)
+               goto error_unbind;
+
+ again:
+       ret = xenbus_transaction_start(&xbt);
+       if (ret)
+               goto error_unreg;
+       ret = xenbus_printf(xbt, "vfb", "page-ref", "%lu",
+                           virt_to_mfn(info->page));
+       if (ret)
+               goto error_xenbus;
+       ret = xenbus_printf(xbt, "vfb", "event-channel", "%u",
+                           info->evtchn);
+       if (ret)
+               goto error_xenbus;
+       ret = xenbus_transaction_end(xbt, 0);
+       if (ret) {
+               if (ret == -EAGAIN)
+                       goto again;
+               goto error_unreg;
+       }
+
+       info->page->initialized = 1; /* FIXME needed?  move up? */
+
+       return 0;
+
+ error_xenbus:
+       xenbus_transaction_end(xbt, 1);
+ error_unreg:
+       unregister_framebuffer(fb_info);
+ error_unbind:
+       unbind_from_irqhandler(xenfb_irq, info);
+       xenfb_irq = 0;
+ error_freep:
+       free_page((unsigned long)info->page);
+ error_kfree:
+       kfree(info->pages);
+ error_vfree:
+       vfree(info->fb);
+ error:
+       kfree(info);
+       xenfb_info = NULL;
+
+       return -ENODEV;
+}
+
+void xenfb_resume(void)
+{
+#if 0 /* FIXME */
+       int i, ret;
+
+       xenfb_info->page = mfn_to_virt(xen_start_info->fbdev_mfn);
+       for (i = 0; i < xenfb_info->nr_pages; i++)
+               xenfb_info->mfns[i] = vmalloc_to_mfn(xenfb_info->fb + i * 
PAGE_SIZE);
+       xenfb_info->page->pd[0] = vmalloc_to_mfn(xenfb_info->mfns);
+
+       if (xenfb_irq)
+               unbind_from_irqhandler(xenfb_irq, NULL);
+
+       printk("xenfb: resume(%d)\n", xen_start_info->fbdev_evtchn);
+       ret = bind_evtchn_to_irqhandler(xen_start_info->fbdev_evtchn,
+                                       xenfb_event_handler, 0, "xenfb", 
xenfb_info);
+       if (ret <= 0)
+               return;
+       xenfb_irq = ret;
+#else
+       printk(KERN_DEBUG "xenfb_resume not implemented\n");
+#endif
+}
+
+static int __init xenfb_init(void)
+{
+       return xenfb_probe();
+}
+
+static void __exit xenfb_cleanup(void)
+{
+       struct xenfb_info *info = xenfb_info;
+
+       unregister_framebuffer(info->fb_info);
+       unbind_from_irqhandler(xenfb_irq, info);
+       xenfb_irq = 0;
+       free_page((unsigned long)info->page);
+       kfree(info->pages);
+       vfree(info->fb);
+       kfree(info);
+       xenfb_info = NULL;
+}
+
+module_init(xenfb_init);
+module_exit(xenfb_cleanup);
+
+MODULE_LICENSE("GPL");
diff -r d8434a6fdd05 drivers/xen/xenkbd/Makefile
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/drivers/xen/xenkbd/Makefile       Mon Jul 10 20:18:50 2006 +0200
@@ -0,0 +1,1 @@
+obj-$(CONFIG_XEN_KEYBOARD)     += xenkbd.o
diff -r d8434a6fdd05 drivers/xen/xenkbd/xenkbd.c
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/drivers/xen/xenkbd/xenkbd.c       Mon Jul 10 20:18:50 2006 +0200
@@ -0,0 +1,205 @@
+/*
+ * linux/drivers/input/keyboard/xenkbd.c -- Xen para-virtual input device
+ *
+ * Copyright (C) 2005
+ *
+ *      Anthony Liguori <aliguori@xxxxxxxxxx>
+ *
+ *  Based on linux/drivers/input/mouse/sermouse.c
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License. See the file COPYING in the main directory of this archive for
+ *  more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <linux/input.h>
+#include <asm/hypervisor.h>
+#include <xen/evtchn.h>
+#include <xen/xenbus.h>
+#include <linux/xenkbd.h>
+
+struct xenkbd_device
+{
+       struct input_dev *dev;
+       struct xenkbd_info *info;
+       unsigned evtchn;
+};
+
+static irqreturn_t input_handler(int rq, void *dev_id, struct pt_regs *regs)
+{
+       struct xenkbd_device *dev = dev_id;
+       struct xenkbd_info *info = dev ? dev->info : 0;
+       static int button_map[3] = { BTN_RIGHT, BTN_MIDDLE, BTN_LEFT };
+       __u32 cons, prod;
+
+       if (!info || !info->initialized)
+               return IRQ_NONE;
+
+       prod = info->in_prod;
+       rmb();                  /* ensure we see ring contents up to prod */
+       for (cons = info->in_cons; cons != prod; cons++) {
+               union xenkbd_in_event *event;
+               event = &XENKBD_RING_REF(info->in, cons);
+       
+               switch (event->type) {
+               case XENKBD_TYPE_MOTION:
+                       input_report_rel(dev->dev, REL_X, event->motion.rel_x);
+                       input_report_rel(dev->dev, REL_Y, event->motion.rel_y);
+                       break;
+               case XENKBD_TYPE_BUTTON:
+                       if (event->button.button < 3)
+                               input_report_key(dev->dev,
+                                                
button_map[event->button.button],
+                                                event->button.pressed);
+                       break;
+               case XENKBD_TYPE_KEY:
+                       input_report_key(dev->dev, event->key.keycode, 
event->key.pressed);
+                       break;
+               }
+
+               notify_remote_via_evtchn(dev->evtchn);
+       }
+       input_sync(dev->dev);
+       /* FIXME do I need a wmb() here? */
+       info->in_cons = cons;
+
+       return IRQ_HANDLED;
+}
+
+static struct xenkbd_device *xenkbd_dev;
+static int xenkbd_irq;
+
+int __init xenkbd_init(void)
+{
+       int ret = 0;
+       int i;
+       struct xenkbd_device *dev;
+       struct input_dev *input_dev;
+       struct evtchn_alloc_unbound alloc_unbound;
+       xenbus_transaction_t xbt;
+
+       dev = kmalloc(sizeof(*dev), GFP_KERNEL);
+       input_dev = input_allocate_device();
+       if (!dev || !input_dev)
+               return -ENOMEM;
+
+       dev->dev = input_dev;
+       dev->info = (void *)__get_free_page(GFP_KERNEL);
+       if (!dev->info) {
+               ret = -ENOMEM;
+               goto error;
+       }
+       dev->info->initialized = 0;
+
+       alloc_unbound.dom = DOMID_SELF;
+       alloc_unbound.remote_dom = 0;
+       ret = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
+                                         &alloc_unbound);
+       if (ret)
+               goto error_freep;
+       dev->evtchn = alloc_unbound.port;
+       ret = bind_evtchn_to_irqhandler(dev->evtchn, input_handler, 0,
+                                       "xenkbd", dev);
+       if (ret < 0)
+               goto error_freep;
+
+       xenkbd_irq = ret;
+
+       input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
+       input_dev->keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT);
+       input_dev->relbit[0] = BIT(REL_X) | BIT(REL_Y);
+
+       /* FIXME not sure this is quite right */
+       for (i = 0; i < 256; i++)
+               set_bit(i, input_dev->keybit);
+
+       input_dev->name = "Xen Virtual Keyboard/Mouse";
+
+       input_register_device(input_dev);
+
+ again:
+       ret = xenbus_transaction_start(&xbt);
+       if (ret)
+               goto error_unreg;
+       ret = xenbus_printf(xbt, "vkbd", "page-ref", "%lu",
+                           virt_to_mfn(dev->info));
+       if (ret)
+               goto error_xenbus;
+       ret = xenbus_printf(xbt, "vkbd", "event-channel", "%u",
+                           dev->evtchn);
+       if (ret)
+               goto error_xenbus;
+       ret = xenbus_transaction_end(xbt, 0);
+       if (ret) {
+               if (ret == -EAGAIN)
+                       goto again;
+               /* FIXME really retry forever? */
+               goto error_unreg;
+       }
+
+       dev->info->in_cons = dev->info->in_prod = 0;
+       dev->info->out_cons = dev->info->out_prod = 0;
+       dev->info->initialized = 1; /* FIXME needed?  move up? */
+
+       xenkbd_dev = dev;
+
+       return ret;
+
+       
+ error_xenbus:
+       xenbus_transaction_end(xbt, 1);
+ error_unreg:
+       input_unregister_device(input_dev);
+       unbind_from_irqhandler(xenkbd_irq, dev);
+       xenkbd_irq = 0;
+ error_freep:
+       free_page((unsigned long)dev->info);
+ error:
+       kfree(dev);
+       xenkbd_dev = NULL;
+       return ret;
+}
+
+static void __exit xenkbd_cleanup(void)
+{
+       input_unregister_device(xenkbd_dev->dev);
+       unbind_from_irqhandler(xenkbd_irq, xenkbd_dev);
+       xenkbd_irq = 0;
+       free_page((unsigned long)xenkbd_dev->info);
+       kfree(xenkbd_dev);
+       xenkbd_dev = NULL;
+}
+
+void xenkbd_resume(void)
+{
+#if 0 /* FIXME */
+       int ret;
+
+       if (xenkbd_dev && xen_start_info->kbd_evtchn) {
+               if (xenkbd_irq)
+                       unbind_from_irqhandler(xenkbd_irq, NULL);
+
+               ret = bind_evtchn_to_irqhandler(xen_start_info->kbd_evtchn,
+                                               input_handler,
+                                               0,
+                                               "xenkbd",
+                                               xenkbd_dev);
+
+               if (ret <= 0)
+                       return;
+
+               xenkbd_irq = ret;
+               xenkbd_dev->info = mfn_to_virt(xen_start_info->kbd_mfn);
+       }
+#else
+       printk(KERN_DEBUG "xenkbd_resume not implemented\n");
+#endif
+}
+
+module_init(xenkbd_init);
+module_exit(xenkbd_cleanup);
+
+MODULE_LICENSE("GPL");
diff -r d8434a6fdd05 include/linux/xenfb.h
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/include/linux/xenfb.h     Mon Jul 10 20:18:50 2006 +0200
@@ -0,0 +1,97 @@
+/*
+ * linux/include/linux/xenfb.h -- Xen virtual frame buffer device
+ *
+ * Copyright (C) 2005
+ *
+ *      Anthony Liguori <aliguori@xxxxxxxxxx>
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License. See the file COPYING in the main directory of this archive for
+ *  more details.
+ */
+
+#ifndef _LINUX_XENFB_H
+#define _LINUX_XENFB_H
+
+#include <asm/types.h>
+
+/* out events */
+
+#define XENFB_TYPE_MOTION 1
+#define XENFB_TYPE_UPDATE 2
+
+struct xenfb_motion
+{
+       __u8 type;          /* XENFB_TYPE_MOTION */
+       __u16 x;            /* The new x coordinate */
+       __u16 y;            /* The new y coordinate */
+};
+
+struct xenfb_update
+{
+       __u8 type;          /* XENFB_TYPE_UPDATE */
+       __u16 x;            /* source x */
+       __u16 y;            /* source y */
+       __u16 width;        /* rect width */
+       __u16 height;       /* rect height */
+};
+
+union xenfb_out_event
+{
+       __u8 type;
+       struct xenfb_motion motion;
+       struct xenfb_update update;
+       char _[40];
+};
+
+/* in events */
+
+#define XENFB_TYPE_SET_EVENTS 1
+
+#define XENFB_FLAG_MOTION 1
+#define XENFB_FLAG_UPDATE 2
+#define XENFB_FLAG_COPY 4
+#define XENFB_FLAG_FILL 8
+
+struct xenfb_set_events
+{
+       __u8 type;          /* XENFB_TYPE_SET_EVENTS */
+       __u32 flags;        /* combination of XENFB_FLAG_* */
+};
+
+union xenfb_in_event
+{
+       __u8 type;
+       struct xenfb_set_events set_events;
+       char _[40];
+};
+
+/* shared page */
+
+#define XENFB_IN_RING_SIZE (1024 / 40)
+#define XENFB_OUT_RING_SIZE (2048 / 40)
+
+#define XENFB_RING_SIZE(ring) (sizeof((ring)) / sizeof(*(ring)))
+#define XENFB_RING_REF(ring, idx) (ring)[(idx) % XENFB_RING_SIZE((ring))]
+
+struct xenfb_page
+{
+       __u8 initialized;
+       __u16 width;         /* the width of the framebuffer (in pixels) */
+       __u16 height;        /* the height of the framebuffer (in pixels) */
+       __u32 line_length;   /* the length of a row of pixels (in bytes) */
+       __u32 mem_length;    /* the length of the framebuffer (in bytes) */
+       __u8 depth;          /* the depth of a pixel (in bits) */
+
+       unsigned long pd[2];
+
+       __u32 in_cons, in_prod;
+       __u32 out_cons, out_prod;
+
+       union xenfb_in_event in[XENFB_IN_RING_SIZE];
+       union xenfb_out_event out[XENFB_OUT_RING_SIZE];
+};
+
+void xenfb_resume(void);
+
+#endif
diff -r d8434a6fdd05 include/linux/xenkbd.h
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/include/linux/xenkbd.h    Mon Jul 10 20:18:50 2006 +0200
@@ -0,0 +1,82 @@
+/*
+ * linux/include/linux/xenkbd.h -- Xen virtual keyboard/mouse
+ *
+ * Copyright (C) 2005
+ *
+ *      Anthony Liguori <aliguori@xxxxxxxxxx>
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License. See the file COPYING in the main directory of this archive for
+ *  more details.
+ */
+
+#ifndef _LINUX_XENKBD_H
+#define _LINUX_XENKBD_H
+
+#include <asm/types.h>
+
+/* in events */
+
+#define XENKBD_TYPE_MOTION  1     /* mouse movement event */
+#define XENKBD_TYPE_BUTTON  2     /* mouse button event */
+#define XENKBD_TYPE_KEY     3     /* keyboard event */
+
+struct xenkbd_motion
+{
+       __u8 type;         /* XENKBD_TYPE_MOTION */
+       __s16 rel_x;       /* relative X motion */
+       __s16 rel_y;       /* relative Y motion */
+};
+
+struct xenkbd_button
+{
+       __u8 type;         /* XENKBD_TYPE_BUTTON */
+       __u8 pressed;      /* 1 if pressed; 0 otherwise */
+       __u8 button;       /* the button (0, 1, 2 is right, middle, left) */
+};
+
+struct xenkbd_key
+{
+       __u8 type;         /* XENKBD_TYPE_KEY */
+       __u8 pressed;      /* 1 if pressed; 0 otherwise */
+       __u16 keycode;     /* KEY_* from linux/input.h */
+};
+
+union xenkbd_in_event
+{
+       __u8 type;
+       struct xenkbd_motion motion;
+       struct xenkbd_button button;
+       struct xenkbd_key key;
+       char _[40];
+};
+
+/* out events */
+
+union xenkbd_out_event
+{
+       __u8 type;
+       char _[40];
+};
+
+/* shared page */
+
+#define XENKBD_IN_RING_SIZE (2048 / 40)
+#define XENKBD_OUT_RING_SIZE (1024 / 40)
+
+#define XENKBD_RING_SIZE(ring) (sizeof((ring)) / sizeof(*(ring)))
+#define XENKBD_RING_REF(ring, idx) (ring)[(idx) % XENKBD_RING_SIZE((ring))]
+
+struct xenkbd_info
+{
+       __u8 initialized;
+       __u32 in_cons, in_prod;
+       __u32 out_cons, out_prod;
+
+       union xenkbd_in_event in[XENKBD_IN_RING_SIZE];
+       union xenkbd_out_event out[XENKBD_OUT_RING_SIZE];
+};
+
+void xenkbd_resume(void);
+
+#endif

_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.