Staging: add mimio xi driver
This patch adds the Mimio Xi interactive whiteboard driver to the tree. It was originally written by mwilder@cs.nmsu.edu, but cleaned up and forward ported by me to the latest kernel version. Cc: Phil Hannent <phil@hannent.co.uk> Cc: <mwilder@cs.nmsu.edu> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Greg Kroah-Hartman
parent
28397ffef1
commit
6e16aee60c
5 changed files with 928 additions and 0 deletions
|
|
@ -85,5 +85,7 @@ source "drivers/staging/rtl8187se/Kconfig"
|
|||
|
||||
source "drivers/staging/rspiusb/Kconfig"
|
||||
|
||||
source "drivers/staging/mimio/Kconfig"
|
||||
|
||||
endif # !STAGING_EXCLUDE_BUILD
|
||||
endif # STAGING
|
||||
|
|
|
|||
|
|
@ -25,3 +25,4 @@ obj-$(CONFIG_PANEL) += panel/
|
|||
obj-$(CONFIG_ALTERA_PCIE_CHDMA) += altpciechdma/
|
||||
obj-$(CONFIG_RTL8187SE) += rtl8187se/
|
||||
obj-$(CONFIG_USB_RSPI) += rspiusb/
|
||||
obj-$(CONFIG_INPUT_MIMIO) += mimio/
|
||||
|
|
|
|||
10
drivers/staging/mimio/Kconfig
Normal file
10
drivers/staging/mimio/Kconfig
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
config INPUT_MIMIO
|
||||
tristate "Mimio Xi interactive whiteboard support"
|
||||
depends on USB
|
||||
default N
|
||||
help
|
||||
Say Y here if you want to use a Mimio Xi interactive
|
||||
whiteboard device.
|
||||
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called mimio.
|
||||
1
drivers/staging/mimio/Makefile
Normal file
1
drivers/staging/mimio/Makefile
Normal file
|
|
@ -0,0 +1 @@
|
|||
obj-$(CONFIG_INPUT_MIMIO) += mimio.o
|
||||
914
drivers/staging/mimio/mimio.c
Normal file
914
drivers/staging/mimio/mimio.c
Normal file
|
|
@ -0,0 +1,914 @@
|
|||
/*
|
||||
* Hardware event => input event mapping:
|
||||
*
|
||||
*
|
||||
*
|
||||
input.h:#define BTN_TOOL_PEN 0x140 black
|
||||
input.h:#define BTN_TOOL_RUBBER 0x141 blue
|
||||
input.h:#define BTN_TOOL_BRUSH 0x142 green
|
||||
input.h:#define BTN_TOOL_PENCIL 0x143 red
|
||||
input.h:#define BTN_TOOL_AIRBRUSH 0x144 eraser
|
||||
input.h:#define BTN_TOOL_FINGER 0x145 small eraser
|
||||
input.h:#define BTN_TOOL_MOUSE 0x146 mimio interactive
|
||||
input.h:#define BTN_TOOL_LENS 0x147 mimio interactive but1
|
||||
input.h:#define LOCALBTN_TOOL_EXTRA1 0x14a mimio interactive but2 == BTN_TOUCH
|
||||
input.h:#define LOCALBTN_TOOL_EXTRA2 0x14b mimio extra pens (orange, brown, yellow, purple) == BTN_STYLUS
|
||||
input.h:#define LOCALBTN_TOOL_EXTRA3 0x14c unused == BTN_STYLUS2
|
||||
input.h:#define BTN_TOOL_DOUBLETAP 0x14d unused
|
||||
input.h:#define BTN_TOOL_TRIPLETAP 0x14e unused
|
||||
*
|
||||
* MIMIO_EV_PENDOWN(MIMIO_PEN_K) => EV_KEY BIT(BTN_TOOL_PEN)
|
||||
* MIMIO_EV_PENDOWN(MIMIO_PEN_B) => EV_KEY BIT(BTN_TOOL_RUBBER)
|
||||
* MIMIO_EV_PENDOWN(MIMIO_PEN_G) => EV_KEY BIT(BTN_TOOL_BRUSH)
|
||||
* MIMIO_EV_PENDOWN(MIMIO_PEN_R) => EV_KEY BIT(BTN_TOOL_PENCIL)
|
||||
* MIMIO_EV_PENDOWN(MIMIO_PEN_E) => EV_KEY BIT(BTN_TOOL_AIRBRUSH)
|
||||
* MIMIO_EV_PENDOWN(MIMIO_PEN_ES) => EV_KEY BIT(BTN_TOOL_FINGER)
|
||||
* MIMIO_EV_PENDOWN(MIMIO_PEN_I) => EV_KEY BIT(BTN_TOOL_MOUSE)
|
||||
* MIMIO_EV_PENDOWN(MIMIO_PEN_IL) => EV_KEY BIT(BTN_TOOL_LENS)
|
||||
* MIMIO_EV_PENDOWN(MIMIO_PEN_IR) => EV_KEY BIT(BTN_TOOL_DOUBLETAP)
|
||||
* MIMIO_EV_PENDOWN(MIMIO_PEN_EX) => EV_KEY BIT(BTN_TOOL_TRIPLETAP)
|
||||
* MIMIO_EV_PENDATA => EV_ABS BIT(ABS_X), BIT(ABS_Y)
|
||||
* MIMIO_EV_MEMRESET => EV_KEY BIT(BTN_0)
|
||||
* MIMIO_EV_ACC(ACC_NEWPAGE) => EV_KEY BIT(BTN_1)
|
||||
* MIMIO_EV_ACC(ACC_TAGPAGE) => EV_KEY BIT(BTN_2)
|
||||
* MIMIO_EV_ACC(ACC_PRINTPAGE) => EV_KEY BIT(BTN_3)
|
||||
* MIMIO_EV_ACC(ACC_MAXIMIZE) => EV_KEY BIT(BTN_4)
|
||||
* MIMIO_EV_ACC(ACC_FINDCTLPNL) => EV_KEY BIT(BTN_5)
|
||||
*
|
||||
*
|
||||
* open issues:
|
||||
* - cold-load of data captured when mimio in standalone mode not yet
|
||||
* supported; need to snoop Win32 box to see datastream for this.
|
||||
* - mimio mouse not yet supported; need to snoop Win32 box to see the
|
||||
* datastream for this.
|
||||
*/
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/input.h>
|
||||
#include <linux/usb.h>
|
||||
|
||||
#define DRIVER_VERSION "v0.031"
|
||||
#define DRIVER_AUTHOR "mwilder@cs.nmsu.edu"
|
||||
#define DRIVER_DESC "USB mimio-xi driver"
|
||||
|
||||
enum {UPVALUE, DOWNVALUE, MOVEVALUE};
|
||||
|
||||
#define MIMIO_XRANGE_MAX 9600
|
||||
#define MIMIO_YRANGE_MAX 4800
|
||||
|
||||
#define LOCALBTN_TOOL_EXTRA1 BTN_TOUCH
|
||||
#define LOCALBTN_TOOL_EXTRA2 BTN_STYLUS
|
||||
#define LOCALBTN_TOOL_EXTRA3 BTN_STYLUS2
|
||||
|
||||
#define MIMIO_VENDOR_ID 0x08d3
|
||||
#define MIMIO_PRODUCT_ID 0x0001
|
||||
#define MIMIO_MAXPAYLOAD (8)
|
||||
#define MIMIO_MAXNAMELEN (64)
|
||||
#define MIMIO_TXWAIT (1)
|
||||
#define MIMIO_TXDONE (2)
|
||||
|
||||
#define MIMIO_EV_PENDOWN (0x22)
|
||||
#define MIMIO_EV_PENDATA (0x24)
|
||||
#define MIMIO_EV_PENUP (0x51)
|
||||
#define MIMIO_EV_MEMRESET (0x45)
|
||||
#define MIMIO_EV_ACC (0xb2)
|
||||
|
||||
#define MIMIO_PEN_K (1) /* black pen */
|
||||
#define MIMIO_PEN_B (2) /* blue pen */
|
||||
#define MIMIO_PEN_G (3) /* green pen */
|
||||
#define MIMIO_PEN_R (4) /* red pen */
|
||||
/* 5, 6, 7, 8 are extra pens */
|
||||
#define MIMIO_PEN_E (9) /* big eraser */
|
||||
#define MIMIO_PEN_ES (10) /* lil eraser */
|
||||
#define MIMIO_PENJUMP_START (10)
|
||||
#define MIMIO_PENJUMP (6)
|
||||
#define MIMIO_PEN_I (17) /* mimio interactive */
|
||||
#define MIMIO_PEN_IL (18) /* mimio interactive button 1 */
|
||||
#define MIMIO_PEN_IR (19) /* mimio interactive button 2 */
|
||||
|
||||
#define MIMIO_PEN_MAX (MIMIO_PEN_IR)
|
||||
|
||||
#define ACC_DONE (0)
|
||||
#define ACC_NEWPAGE (1)
|
||||
#define ACC_TAGPAGE (2)
|
||||
#define ACC_PRINTPAGE (4)
|
||||
#define ACC_MAXIMIZE (8)
|
||||
#define ACC_FINDCTLPNL (16)
|
||||
|
||||
#define isvalidtxsize(n) ((n) > 0 && (n) <= MIMIO_MAXPAYLOAD)
|
||||
|
||||
|
||||
struct pktbuf {
|
||||
unsigned char instr;
|
||||
unsigned char buf[16];
|
||||
unsigned char *p;
|
||||
unsigned char *q;
|
||||
};
|
||||
|
||||
struct usbintendpt {
|
||||
dma_addr_t dma;
|
||||
struct urb *urb;
|
||||
unsigned char *buf;
|
||||
struct usb_endpoint_descriptor *desc;
|
||||
};
|
||||
|
||||
struct mimio {
|
||||
struct input_dev *idev;
|
||||
struct usb_device *udev;
|
||||
struct usb_interface *uifc;
|
||||
int open;
|
||||
int present;
|
||||
int greeted;
|
||||
int txflags;
|
||||
char phys[MIMIO_MAXNAMELEN];
|
||||
struct usbintendpt in;
|
||||
struct usbintendpt out;
|
||||
struct pktbuf pktbuf;
|
||||
unsigned char minor;
|
||||
wait_queue_head_t waitq;
|
||||
spinlock_t txlock;
|
||||
void (*rxhandler)(struct mimio *, unsigned char *, unsigned int);
|
||||
int last_pen_down;
|
||||
};
|
||||
|
||||
static void mimio_close(struct input_dev *);
|
||||
static void mimio_dealloc(struct mimio *);
|
||||
static void mimio_disconnect(struct usb_interface *);
|
||||
static int mimio_greet(struct mimio *);
|
||||
static void mimio_irq_in(struct urb *);
|
||||
static void mimio_irq_out(struct urb *);
|
||||
static int mimio_open(struct input_dev *);
|
||||
static int mimio_probe(struct usb_interface *, const struct usb_device_id *);
|
||||
static void mimio_rx_handler(struct mimio *, unsigned char *, unsigned int);
|
||||
static int mimio_tx(struct mimio *, const char *, int);
|
||||
|
||||
static char mimio_name[] = "VirtualInk mimio-Xi";
|
||||
static struct usb_device_id mimio_table [] = {
|
||||
{ USB_DEVICE(MIMIO_VENDOR_ID, MIMIO_PRODUCT_ID) },
|
||||
{ USB_DEVICE(0x0525, 0xa4a0) }, /* gadget zero firmware */
|
||||
{ }
|
||||
};
|
||||
|
||||
MODULE_DEVICE_TABLE(usb, mimio_table);
|
||||
|
||||
static struct usb_driver mimio_driver = {
|
||||
.name = "mimio",
|
||||
.probe = mimio_probe,
|
||||
.disconnect = mimio_disconnect,
|
||||
.id_table = mimio_table,
|
||||
};
|
||||
|
||||
static DECLARE_MUTEX(disconnect_sem);
|
||||
|
||||
static void mimio_close(struct input_dev *idev)
|
||||
{
|
||||
struct mimio *mimio;
|
||||
|
||||
mimio = input_get_drvdata(idev);
|
||||
if (!mimio) {
|
||||
dev_err(&idev->dev, "null mimio attached to input device\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (mimio->open <= 0)
|
||||
dev_err(&idev->dev, "mimio not open.\n");
|
||||
else
|
||||
mimio->open--;
|
||||
|
||||
if (mimio->present == 0 && mimio->open == 0)
|
||||
mimio_dealloc(mimio);
|
||||
}
|
||||
|
||||
static void mimio_dealloc(struct mimio *mimio)
|
||||
{
|
||||
if (mimio == NULL)
|
||||
return;
|
||||
|
||||
usb_kill_urb(mimio->in.urb);
|
||||
|
||||
usb_kill_urb(mimio->out.urb);
|
||||
|
||||
if (mimio->idev) {
|
||||
input_unregister_device(mimio->idev);
|
||||
if (mimio->idev->grab)
|
||||
input_close_device(mimio->idev->grab);
|
||||
else
|
||||
dev_dbg(&mimio->idev->dev, "mimio->idev->grab == NULL"
|
||||
" -- didn't call input_close_device\n");
|
||||
}
|
||||
|
||||
usb_free_urb(mimio->in.urb);
|
||||
|
||||
usb_free_urb(mimio->out.urb);
|
||||
|
||||
if (mimio->in.buf) {
|
||||
usb_buffer_free(mimio->udev, MIMIO_MAXPAYLOAD, mimio->in.buf,
|
||||
mimio->in.dma);
|
||||
}
|
||||
|
||||
if (mimio->out.buf)
|
||||
usb_buffer_free(mimio->udev, MIMIO_MAXPAYLOAD, mimio->out.buf,
|
||||
mimio->out.dma);
|
||||
|
||||
if (mimio->idev)
|
||||
input_free_device(mimio->idev);
|
||||
|
||||
kfree(mimio);
|
||||
}
|
||||
|
||||
static void mimio_disconnect(struct usb_interface *ifc)
|
||||
{
|
||||
struct mimio *mimio;
|
||||
|
||||
down(&disconnect_sem);
|
||||
|
||||
mimio = usb_get_intfdata(ifc);
|
||||
usb_set_intfdata(ifc, NULL);
|
||||
dev_dbg(&mimio->idev->dev, "disconnect\n");
|
||||
|
||||
if (mimio) {
|
||||
mimio->present = 0;
|
||||
|
||||
if (mimio->open <= 0)
|
||||
mimio_dealloc(mimio);
|
||||
}
|
||||
|
||||
up(&disconnect_sem);
|
||||
}
|
||||
|
||||
static int mimio_greet(struct mimio *mimio)
|
||||
{
|
||||
const struct grtpkt {
|
||||
int nbytes;
|
||||
unsigned delay;
|
||||
char data[8];
|
||||
} grtpkts[] = {
|
||||
{ 3, 0, { 0x11, 0x55, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00 } },
|
||||
{ 5, 0, { 0x53, 0x55, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00 } },
|
||||
{ 5, 0, { 0x43, 0x55, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00 } },
|
||||
{ 5, 0, { 0x33, 0x55, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00 } },
|
||||
{ 5, 0, { 0x13, 0x00, 0x5e, 0x02, 0x4f, 0x00, 0x00, 0x00 } },
|
||||
{ 5, 0, { 0x13, 0x00, 0x04, 0x03, 0x14, 0x00, 0x00, 0x00 } },
|
||||
{ 5, 2, { 0x13, 0x00, 0x00, 0x04, 0x17, 0x00, 0x00, 0x00 } },
|
||||
{ 5, 0, { 0x13, 0x00, 0x0d, 0x08, 0x16, 0x00, 0x00, 0x00 } },
|
||||
{ 5, 0, { 0x13, 0x00, 0x4d, 0x01, 0x5f, 0x00, 0x00, 0x00 } },
|
||||
{ 3, 0, { 0xf1, 0x55, 0xa4, 0x00, 0x00, 0x00, 0x00, 0x00 } },
|
||||
{ 7, 2, { 0x52, 0x55, 0x00, 0x07, 0x31, 0x55, 0x64, 0x00 } },
|
||||
{ 0, 0, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
|
||||
};
|
||||
int rslt;
|
||||
const struct grtpkt *pkt;
|
||||
|
||||
for (pkt = grtpkts; pkt->nbytes; pkt++) {
|
||||
rslt = mimio_tx(mimio, pkt->data, pkt->nbytes);
|
||||
if (rslt)
|
||||
return rslt;
|
||||
if (pkt->delay)
|
||||
msleep(pkt->delay);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mimio_irq_in(struct urb *urb)
|
||||
{
|
||||
int rslt;
|
||||
char *data;
|
||||
const char *reason = "going down";
|
||||
struct mimio *mimio;
|
||||
|
||||
mimio = urb->context;
|
||||
|
||||
if (mimio == NULL)
|
||||
/* paranoia */
|
||||
return;
|
||||
|
||||
switch (urb->status) {
|
||||
case 0:
|
||||
/* success */
|
||||
break;
|
||||
case -ETIMEDOUT:
|
||||
reason = "timeout -- unplugged?";
|
||||
case -ECONNRESET:
|
||||
case -ENOENT:
|
||||
case -ESHUTDOWN:
|
||||
dev_dbg(&mimio->idev->dev, "%s.\n", reason);
|
||||
return;
|
||||
default:
|
||||
dev_dbg(&mimio->idev->dev, "unknown urb-status: %d.\n",
|
||||
urb->status);
|
||||
goto exit;
|
||||
}
|
||||
data = mimio->in.buf;
|
||||
|
||||
if (mimio->rxhandler)
|
||||
mimio->rxhandler(mimio, data, urb->actual_length);
|
||||
exit:
|
||||
/*
|
||||
* Keep listening to device on same urb.
|
||||
*/
|
||||
rslt = usb_submit_urb(urb, GFP_ATOMIC);
|
||||
if (rslt)
|
||||
dev_err(&mimio->idev->dev, "usb_submit_urb failure: %d.\n",
|
||||
rslt);
|
||||
}
|
||||
|
||||
static void mimio_irq_out(struct urb *urb)
|
||||
{
|
||||
unsigned long flags;
|
||||
struct mimio *mimio;
|
||||
|
||||
mimio = urb->context;
|
||||
|
||||
if (urb->status)
|
||||
dev_dbg(&mimio->idev->dev, "urb-status: %d.\n", urb->status);
|
||||
|
||||
spin_lock_irqsave(&mimio->txlock, flags);
|
||||
mimio->txflags |= MIMIO_TXDONE;
|
||||
spin_unlock_irqrestore(&mimio->txlock, flags);
|
||||
wmb();
|
||||
wake_up(&mimio->waitq);
|
||||
}
|
||||
|
||||
static int mimio_open(struct input_dev *idev)
|
||||
{
|
||||
int rslt;
|
||||
struct mimio *mimio;
|
||||
|
||||
rslt = 0;
|
||||
down(&disconnect_sem);
|
||||
mimio = input_get_drvdata(idev);
|
||||
dev_dbg(&idev->dev, "mimio_open\n");
|
||||
|
||||
if (mimio == NULL) {
|
||||
dev_err(&idev->dev, "null mimio.\n");
|
||||
rslt = -ENODEV;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (mimio->open++)
|
||||
goto exit;
|
||||
|
||||
if (mimio->present && !mimio->greeted) {
|
||||
struct urb *urb = mimio->in.urb;
|
||||
mimio->in.urb->dev = mimio->udev;
|
||||
rslt = usb_submit_urb(mimio->in.urb, GFP_KERNEL);
|
||||
if (rslt) {
|
||||
dev_err(&idev->dev, "usb_submit_urb failure "
|
||||
"(res = %d: %s). Not greeting.\n",
|
||||
rslt,
|
||||
(!urb ? "urb is NULL" :
|
||||
(urb->hcpriv ? "urb->hcpriv is non-NULL" :
|
||||
(!urb->complete ? "urb is not complete" :
|
||||
(urb->number_of_packets <= 0 ? "urb has no packets" :
|
||||
(urb->interval <= 0 ? "urb interval too small" :
|
||||
"urb interval too large or some other error"))))));
|
||||
rslt = -EIO;
|
||||
goto exit;
|
||||
}
|
||||
rslt = mimio_greet(mimio);
|
||||
if (rslt == 0) {
|
||||
dev_dbg(&idev->dev, "Mimio greeted OK.\n");
|
||||
mimio->greeted = 1;
|
||||
} else {
|
||||
dev_dbg(&idev->dev, "Mimio greet Failure (%d)\n",
|
||||
rslt);
|
||||
}
|
||||
}
|
||||
|
||||
exit:
|
||||
up(&disconnect_sem);
|
||||
return rslt;
|
||||
}
|
||||
|
||||
static int mimio_probe(struct usb_interface *ifc,
|
||||
const struct usb_device_id *id)
|
||||
{
|
||||
char path[64];
|
||||
int pipe, maxp;
|
||||
struct mimio *mimio;
|
||||
struct usb_device *udev;
|
||||
struct usb_host_interface *hostifc;
|
||||
struct input_dev *input_dev;
|
||||
int res = 0;
|
||||
int i;
|
||||
|
||||
udev = interface_to_usbdev(ifc);
|
||||
|
||||
mimio = kzalloc(sizeof(struct mimio), GFP_KERNEL);
|
||||
if (!mimio)
|
||||
return -ENOMEM;
|
||||
|
||||
input_dev = input_allocate_device();
|
||||
if (!input_dev) {
|
||||
mimio_dealloc(mimio);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
mimio->uifc = ifc;
|
||||
mimio->udev = udev;
|
||||
mimio->pktbuf.p = mimio->pktbuf.buf;
|
||||
mimio->pktbuf.q = mimio->pktbuf.buf;
|
||||
/* init_input_dev(mimio->idev); */
|
||||
mimio->idev = input_dev;
|
||||
init_waitqueue_head(&mimio->waitq);
|
||||
spin_lock_init(&mimio->txlock);
|
||||
hostifc = ifc->cur_altsetting;
|
||||
|
||||
if (hostifc->desc.bNumEndpoints != 2) {
|
||||
dev_err(&udev->dev, "Unexpected endpoint count: %d.\n",
|
||||
hostifc->desc.bNumEndpoints);
|
||||
mimio_dealloc(mimio);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
mimio->in.desc = &(hostifc->endpoint[0].desc);
|
||||
mimio->out.desc = &(hostifc->endpoint[1].desc);
|
||||
|
||||
mimio->in.buf = usb_buffer_alloc(udev, MIMIO_MAXPAYLOAD, GFP_KERNEL,
|
||||
&mimio->in.dma);
|
||||
mimio->out.buf = usb_buffer_alloc(udev, MIMIO_MAXPAYLOAD, GFP_KERNEL,
|
||||
&mimio->out.dma);
|
||||
|
||||
if (mimio->in.buf == NULL || mimio->out.buf == NULL) {
|
||||
dev_err(&udev->dev, "usb_buffer_alloc failure.\n");
|
||||
mimio_dealloc(mimio);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
mimio->in.urb = usb_alloc_urb(0, GFP_KERNEL);
|
||||
mimio->out.urb = usb_alloc_urb(0, GFP_KERNEL);
|
||||
|
||||
if (mimio->in.urb == NULL || mimio->out.urb == NULL) {
|
||||
dev_err(&udev->dev, "usb_alloc_urb failure.\n");
|
||||
mimio_dealloc(mimio);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/*
|
||||
* Build the input urb.
|
||||
*/
|
||||
pipe = usb_rcvintpipe(udev, mimio->in.desc->bEndpointAddress);
|
||||
maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
|
||||
if (maxp > MIMIO_MAXPAYLOAD)
|
||||
maxp = MIMIO_MAXPAYLOAD;
|
||||
usb_fill_int_urb(mimio->in.urb, udev, pipe, mimio->in.buf, maxp,
|
||||
mimio_irq_in, mimio, mimio->in.desc->bInterval);
|
||||
mimio->in.urb->transfer_dma = mimio->in.dma;
|
||||
mimio->in.urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
|
||||
|
||||
/*
|
||||
* Build the output urb.
|
||||
*/
|
||||
pipe = usb_sndintpipe(udev, mimio->out.desc->bEndpointAddress);
|
||||
maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
|
||||
if (maxp > MIMIO_MAXPAYLOAD)
|
||||
maxp = MIMIO_MAXPAYLOAD;
|
||||
usb_fill_int_urb(mimio->out.urb, udev, pipe, mimio->out.buf, maxp,
|
||||
mimio_irq_out, mimio, mimio->out.desc->bInterval);
|
||||
mimio->out.urb->transfer_dma = mimio->out.dma;
|
||||
mimio->out.urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
|
||||
|
||||
/*
|
||||
* Build input device info
|
||||
*/
|
||||
usb_make_path(udev, path, 64);
|
||||
snprintf(mimio->phys, MIMIO_MAXNAMELEN, "%s/input0", path);
|
||||
input_set_drvdata(input_dev, mimio);
|
||||
/* input_dev->dev = &ifc->dev; */
|
||||
input_dev->open = mimio_open;
|
||||
input_dev->close = mimio_close;
|
||||
input_dev->name = mimio_name;
|
||||
input_dev->phys = mimio->phys;
|
||||
input_dev->dev.parent = &ifc->dev;
|
||||
|
||||
input_dev->id.bustype = BUS_USB;
|
||||
input_dev->id.vendor = le16_to_cpu(udev->descriptor.idVendor);
|
||||
input_dev->id.product = le16_to_cpu(udev->descriptor.idProduct);
|
||||
input_dev->id.version = le16_to_cpu(udev->descriptor.bcdDevice);
|
||||
|
||||
input_dev->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS);
|
||||
for (i = BTN_TOOL_PEN; i <= LOCALBTN_TOOL_EXTRA2; ++i)
|
||||
set_bit(i, input_dev->keybit);
|
||||
|
||||
input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_0) |
|
||||
BIT_MASK(BTN_1) |
|
||||
BIT_MASK(BTN_2) |
|
||||
BIT_MASK(BTN_3) |
|
||||
BIT_MASK(BTN_4) |
|
||||
BIT_MASK(BTN_5);
|
||||
/* input_dev->keybit[BTN_MOUSE] |= BIT(BTN_LEFT); */
|
||||
input_dev->absbit[0] |= BIT_MASK(ABS_X) | BIT_MASK(ABS_Y);
|
||||
input_set_abs_params(input_dev, ABS_X, 0, MIMIO_XRANGE_MAX, 0, 0);
|
||||
input_set_abs_params(input_dev, ABS_Y, 0, MIMIO_YRANGE_MAX, 0, 0);
|
||||
input_dev->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
|
||||
|
||||
#if 0
|
||||
input_dev->absmin[ABS_X] = 0;
|
||||
input_dev->absmin[ABS_Y] = 0;
|
||||
input_dev->absmax[ABS_X] = 9600;
|
||||
input_dev->absmax[ABS_Y] = 4800;
|
||||
input_dev->absfuzz[ABS_X] = 0;
|
||||
input_dev->absfuzz[ABS_Y] = 0;
|
||||
input_dev->absflat[ABS_X] = 0;
|
||||
input_dev->absflat[ABS_Y] = 0;
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
/* this will just reduce the precision */
|
||||
input_dev->absfuzz[ABS_X] = 8; /* experimental; may need to change */
|
||||
input_dev->absfuzz[ABS_Y] = 8; /* experimental; may need to change */
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Register the input device.
|
||||
*/
|
||||
res = input_register_device(mimio->idev);
|
||||
if (res) {
|
||||
dev_err(&udev->dev, "input_register_device failure (%d)\n",
|
||||
res);
|
||||
mimio_dealloc(mimio);
|
||||
return -EIO;
|
||||
}
|
||||
dev_dbg(&mimio->idev->dev, "input: %s on %s (res = %d).\n",
|
||||
input_dev->name, input_dev->phys, res);
|
||||
|
||||
usb_set_intfdata(ifc, mimio);
|
||||
mimio->present = 1;
|
||||
|
||||
/*
|
||||
* Submit the input urb to the usb subsystem.
|
||||
*/
|
||||
mimio->in.urb->dev = mimio->udev;
|
||||
res = usb_submit_urb(mimio->in.urb, GFP_KERNEL);
|
||||
if (res) {
|
||||
dev_err(&mimio->idev->dev, "usb_submit_urb failure (%d)\n",
|
||||
res);
|
||||
mimio_dealloc(mimio);
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
/*
|
||||
* Attempt to greet the mimio after giving
|
||||
* it some post-init settling time.
|
||||
*
|
||||
* note: sometimes this sleep interval isn't
|
||||
* long enough to permit the device to re-init
|
||||
* after a hot-swap; maybe need to bump it up.
|
||||
*
|
||||
* As it is, this probably breaks module unloading support!
|
||||
*/
|
||||
msleep(1024);
|
||||
|
||||
res = mimio_greet(mimio);
|
||||
if (res == 0) {
|
||||
dev_dbg(&mimio->idev->dev, "Mimio greeted OK.\n");
|
||||
mimio->greeted = 1;
|
||||
mimio->rxhandler = mimio_rx_handler;
|
||||
} else {
|
||||
dev_dbg(&mimio->idev->dev, "Mimio greet Failure (%d)\n", res);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int handle_mimio_rx_penupdown(struct mimio *mimio,
|
||||
int down,
|
||||
const char *const instr[],
|
||||
const int instr_ofst[])
|
||||
{
|
||||
int penid, x;
|
||||
if (mimio->pktbuf.q - mimio->pktbuf.p < (down ? 4 : 3))
|
||||
return 1; /* partial pkt */
|
||||
|
||||
if (down) {
|
||||
x = *mimio->pktbuf.p ^ *(mimio->pktbuf.p + 1) ^
|
||||
*(mimio->pktbuf.p + 2);
|
||||
if (x != *(mimio->pktbuf.p + 3)) {
|
||||
dev_dbg(&mimio->idev->dev, "EV_PEN%s: bad xsum.\n",
|
||||
down ? "DOWN":"UP");
|
||||
/* skip this event data */
|
||||
mimio->pktbuf.p += 4;
|
||||
/* decode any remaining events */
|
||||
return 0;
|
||||
}
|
||||
penid = mimio->pktbuf.instr = *(mimio->pktbuf.p + 2);
|
||||
if (penid > MIMIO_PEN_MAX) {
|
||||
dev_dbg(&mimio->idev->dev,
|
||||
"Unmapped penID (not in [0, %d]): %d\n",
|
||||
MIMIO_PEN_MAX, (int)mimio->pktbuf.instr);
|
||||
penid = mimio->pktbuf.instr = 0;
|
||||
}
|
||||
mimio->last_pen_down = penid;
|
||||
} else {
|
||||
penid = mimio->last_pen_down;
|
||||
}
|
||||
dev_dbg(&mimio->idev->dev, "%s (id %d, code %d) %s.\n", instr[penid],
|
||||
instr_ofst[penid], penid, down ? "down" : "up");
|
||||
|
||||
if (instr_ofst[penid] >= 0) {
|
||||
int code = BTN_TOOL_PEN + instr_ofst[penid];
|
||||
int value = down ? DOWNVALUE : UPVALUE;
|
||||
if (code > KEY_MAX)
|
||||
dev_dbg(&mimio->idev->dev, "input_event will ignore "
|
||||
"-- code (%d) > KEY_MAX\n", code);
|
||||
if (!test_bit(code, mimio->idev->keybit))
|
||||
dev_dbg(&mimio->idev->dev, "input_event will ignore "
|
||||
"-- bit for code (%d) not enabled\n", code);
|
||||
if (!!test_bit(code, mimio->idev->key) == value)
|
||||
dev_dbg(&mimio->idev->dev, "input_event will ignore "
|
||||
"-- bit for code (%d) already set to %d\n",
|
||||
code, value);
|
||||
if (value != DOWNVALUE) {
|
||||
/* input_regs(mimio->idev, regs); */
|
||||
input_report_key(mimio->idev, code, value);
|
||||
input_sync(mimio->idev);
|
||||
} else {
|
||||
/* wait until we get some coordinates */
|
||||
}
|
||||
} else {
|
||||
dev_dbg(&mimio->idev->dev, "penID offset[%d] == %d is < 0 "
|
||||
"- not sending\n", penid, instr_ofst[penid]);
|
||||
}
|
||||
mimio->pktbuf.p += down ? 4 : 3; /* 3 for up, 4 for down */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Stay tuned for partial-packet excitement.
|
||||
*
|
||||
* This routine buffers data packets received from the mimio device
|
||||
* in the mimio's data space. This buffering is necessary because
|
||||
* the mimio's in endpoint can serve us partial packets of data, and
|
||||
* we want the driver to support the servicing of multiple mimios.
|
||||
* Empirical evidence gathered so far suggests that the method of
|
||||
* buffering packet data in the mimio's data space works. Previous
|
||||
* versions of this driver did not buffer packet data in each mimio's
|
||||
* data-space, and were therefore not able to service multiple mimios.
|
||||
* Note that since the caller of this routine is running in interrupt
|
||||
* context, care needs to be taken to ensure that this routine does not
|
||||
* become bloated, and it may be that another spinlock is needed in each
|
||||
* mimio to guard the buffered packet data properly.
|
||||
*/
|
||||
static void mimio_rx_handler(struct mimio *mimio,
|
||||
unsigned char *data,
|
||||
unsigned int nbytes)
|
||||
{
|
||||
struct device *dev = &mimio->idev->dev;
|
||||
unsigned int x;
|
||||
unsigned int y;
|
||||
static const char * const instr[] = {
|
||||
"?0",
|
||||
"black pen", "blue pen", "green pen", "red pen",
|
||||
"brown pen", "orange pen", "purple pen", "yellow pen",
|
||||
"big eraser", "lil eraser",
|
||||
"?11", "?12", "?13", "?14", "?15", "?16",
|
||||
"mimio interactive", "interactive button1",
|
||||
"interactive button2"
|
||||
};
|
||||
|
||||
/* Mimio Interactive gives:
|
||||
* down: [0x22 0x01 0x11 0x32 0x24]
|
||||
* b1 : [0x22 0x01 0x12 0x31 0x24]
|
||||
* b2 : [0x22 0x01 0x13 0x30 0x24]
|
||||
*/
|
||||
static const int instr_ofst[] = {
|
||||
-1,
|
||||
0, 1, 2, 3,
|
||||
9, 9, 9, 9,
|
||||
4, 5,
|
||||
-1, -1, -1, -1, -1, -1,
|
||||
6, 7, 8,
|
||||
};
|
||||
|
||||
memcpy(mimio->pktbuf.q, data, nbytes);
|
||||
mimio->pktbuf.q += nbytes;
|
||||
|
||||
while (mimio->pktbuf.p < mimio->pktbuf.q) {
|
||||
int t = *mimio->pktbuf.p;
|
||||
switch (t) {
|
||||
case MIMIO_EV_PENUP:
|
||||
case MIMIO_EV_PENDOWN:
|
||||
if (handle_mimio_rx_penupdown(mimio,
|
||||
t == MIMIO_EV_PENDOWN,
|
||||
instr, instr_ofst))
|
||||
return; /* partial packet */
|
||||
break;
|
||||
|
||||
case MIMIO_EV_PENDATA:
|
||||
if (mimio->pktbuf.q - mimio->pktbuf.p < 6)
|
||||
/* partial pkt */
|
||||
return;
|
||||
x = *mimio->pktbuf.p ^ *(mimio->pktbuf.p + 1) ^
|
||||
*(mimio->pktbuf.p + 2) ^
|
||||
*(mimio->pktbuf.p + 3) ^
|
||||
*(mimio->pktbuf.p + 4);
|
||||
if (x != *(mimio->pktbuf.p + 5)) {
|
||||
dev_dbg(dev, "EV_PENDATA: bad xsum.\n");
|
||||
mimio->pktbuf.p += 6; /* skip this event data */
|
||||
break; /* decode any remaining events */
|
||||
}
|
||||
x = *(mimio->pktbuf.p + 1);
|
||||
x <<= 8;
|
||||
x |= *(mimio->pktbuf.p + 2);
|
||||
y = *(mimio->pktbuf.p + 3);
|
||||
y <<= 8;
|
||||
y |= *(mimio->pktbuf.p + 4);
|
||||
dev_dbg(dev, "coord: (%d, %d)\n", x, y);
|
||||
if (instr_ofst[mimio->pktbuf.instr] >= 0) {
|
||||
int code = BTN_TOOL_PEN +
|
||||
instr_ofst[mimio->last_pen_down];
|
||||
#if 0
|
||||
/* Utter hack to ensure we get forwarded _AND_
|
||||
* so we can identify when a complete signal is
|
||||
* received */
|
||||
mimio->idev->abs[ABS_Y] = -1;
|
||||
mimio->idev->abs[ABS_X] = -1;
|
||||
#endif
|
||||
/* input_regs(mimio->idev, regs); */
|
||||
input_report_abs(mimio->idev, ABS_X, x);
|
||||
input_report_abs(mimio->idev, ABS_Y, y);
|
||||
/* fake a penup */
|
||||
change_bit(code, mimio->idev->key);
|
||||
input_report_key(mimio->idev,
|
||||
code,
|
||||
DOWNVALUE);
|
||||
/* always sync here */
|
||||
mimio->idev->sync = 0;
|
||||
input_sync(mimio->idev);
|
||||
}
|
||||
mimio->pktbuf.p += 6;
|
||||
break;
|
||||
case MIMIO_EV_MEMRESET:
|
||||
if (mimio->pktbuf.q - mimio->pktbuf.p < 7)
|
||||
/* partial pkt */
|
||||
return;
|
||||
dev_dbg(dev, "mem-reset.\n");
|
||||
/* input_regs(mimio->idev, regs); */
|
||||
input_event(mimio->idev, EV_KEY, BTN_0, 1);
|
||||
input_event(mimio->idev, EV_KEY, BTN_0, 0);
|
||||
input_sync(mimio->idev);
|
||||
mimio->pktbuf.p += 7;
|
||||
break;
|
||||
case MIMIO_EV_ACC:
|
||||
if (mimio->pktbuf.q - mimio->pktbuf.p < 4)
|
||||
/* partial pkt */
|
||||
return;
|
||||
x = *mimio->pktbuf.p ^ *(mimio->pktbuf.p + 1) ^
|
||||
*(mimio->pktbuf.p + 2);
|
||||
if (x != *(mimio->pktbuf.p + 3)) {
|
||||
dev_dbg(dev, "EV_ACC: bad xsum.\n");
|
||||
mimio->pktbuf.p += 4; /* skip this event data */
|
||||
break; /* decode any remaining events */
|
||||
}
|
||||
switch (*(mimio->pktbuf.p + 2)) {
|
||||
case ACC_NEWPAGE:
|
||||
dev_dbg(&mimio->idev->dev, "new-page.\n");
|
||||
/* input_regs(mimio->idev, regs); */
|
||||
input_event(mimio->idev, EV_KEY, BTN_1, 1);
|
||||
input_event(mimio->idev, EV_KEY, BTN_1, 0);
|
||||
input_sync(mimio->idev);
|
||||
break;
|
||||
case ACC_TAGPAGE:
|
||||
dev_dbg(&mimio->idev->dev, "tag-page.\n");
|
||||
/* input_regs(mimio->idev, regs); */
|
||||
input_event(mimio->idev, EV_KEY, BTN_2, 1);
|
||||
input_event(mimio->idev, EV_KEY, BTN_2, 0);
|
||||
input_sync(mimio->idev);
|
||||
break;
|
||||
case ACC_PRINTPAGE:
|
||||
dev_dbg(&mimio->idev->dev, "print-page.\n");
|
||||
/* input_regs(mimio->idev, regs);*/
|
||||
input_event(mimio->idev, EV_KEY, BTN_3, 1);
|
||||
input_event(mimio->idev, EV_KEY, BTN_3, 0);
|
||||
input_sync(mimio->idev);
|
||||
break;
|
||||
case ACC_MAXIMIZE:
|
||||
dev_dbg(&mimio->idev->dev,
|
||||
"maximize-window.\n");
|
||||
/* input_regs(mimio->idev, regs); */
|
||||
input_event(mimio->idev, EV_KEY, BTN_4, 1);
|
||||
input_event(mimio->idev, EV_KEY, BTN_4, 0);
|
||||
input_sync(mimio->idev);
|
||||
break;
|
||||
case ACC_FINDCTLPNL:
|
||||
dev_dbg(&mimio->idev->dev, "find-ctl-panel.\n");
|
||||
/* input_regs(mimio->idev, regs); */
|
||||
input_event(mimio->idev, EV_KEY, BTN_5, 1);
|
||||
input_event(mimio->idev, EV_KEY, BTN_5, 0);
|
||||
input_sync(mimio->idev);
|
||||
break;
|
||||
case ACC_DONE:
|
||||
dev_dbg(&mimio->idev->dev, "acc-done.\n");
|
||||
/* no event is dispatched to the input
|
||||
* subsystem for this device event.
|
||||
*/
|
||||
break;
|
||||
default:
|
||||
dev_dbg(dev, "unknown acc event.\n");
|
||||
break;
|
||||
}
|
||||
mimio->pktbuf.p += 4;
|
||||
break;
|
||||
default:
|
||||
mimio->pktbuf.p++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* No partial event was received, so reset mimio's pktbuf ptrs.
|
||||
*/
|
||||
mimio->pktbuf.p = mimio->pktbuf.q = mimio->pktbuf.buf;
|
||||
}
|
||||
|
||||
static int mimio_tx(struct mimio *mimio, const char *buf, int nbytes)
|
||||
{
|
||||
int rslt;
|
||||
int timeout;
|
||||
unsigned long flags;
|
||||
DECLARE_WAITQUEUE(wait, current);
|
||||
|
||||
if (!(isvalidtxsize(nbytes))) {
|
||||
dev_err(&mimio->idev->dev, "invalid arg: nbytes: %d.\n",
|
||||
nbytes);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Init the out urb and copy the data to send.
|
||||
*/
|
||||
mimio->out.urb->dev = mimio->udev;
|
||||
mimio->out.urb->transfer_buffer_length = nbytes;
|
||||
memcpy(mimio->out.urb->transfer_buffer, buf, nbytes);
|
||||
|
||||
/*
|
||||
* Send the data.
|
||||
*/
|
||||
spin_lock_irqsave(&mimio->txlock, flags);
|
||||
mimio->txflags = MIMIO_TXWAIT;
|
||||
rslt = usb_submit_urb(mimio->out.urb, GFP_ATOMIC);
|
||||
spin_unlock_irqrestore(&mimio->txlock, flags);
|
||||
dev_dbg(&mimio->idev->dev, "rslt: %d.\n", rslt);
|
||||
|
||||
if (rslt) {
|
||||
dev_err(&mimio->idev->dev, "usb_submit_urb failure: %d.\n",
|
||||
rslt);
|
||||
return rslt;
|
||||
}
|
||||
|
||||
/*
|
||||
* Wait for completion to be signalled (the mimio_irq_out
|
||||
* completion routine will or MIMIO_TXDONE in with txflags).
|
||||
*/
|
||||
timeout = HZ;
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
add_wait_queue(&mimio->waitq, &wait);
|
||||
|
||||
while (timeout && ((mimio->txflags & MIMIO_TXDONE) == 0)) {
|
||||
timeout = schedule_timeout(timeout);
|
||||
rmb();
|
||||
}
|
||||
|
||||
if ((mimio->txflags & MIMIO_TXDONE) == 0)
|
||||
dev_dbg(&mimio->idev->dev, "tx timed out.\n");
|
||||
|
||||
/*
|
||||
* Now that completion has been signalled,
|
||||
* unlink the urb so that it can be recycled.
|
||||
*/
|
||||
set_current_state(TASK_RUNNING);
|
||||
remove_wait_queue(&mimio->waitq, &wait);
|
||||
usb_unlink_urb(mimio->out.urb);
|
||||
|
||||
return rslt;
|
||||
}
|
||||
|
||||
static int __init mimio_init(void)
|
||||
{
|
||||
int rslt;
|
||||
|
||||
rslt = usb_register(&mimio_driver);
|
||||
if (rslt != 0) {
|
||||
err("%s: usb_register failure: %d", __func__, rslt);
|
||||
return rslt;
|
||||
}
|
||||
|
||||
printk(KERN_INFO KBUILD_MODNAME ":"
|
||||
DRIVER_DESC " " DRIVER_VERSION "\n");
|
||||
return rslt;
|
||||
}
|
||||
|
||||
static void __exit mimio_exit(void)
|
||||
{
|
||||
usb_deregister(&mimio_driver);
|
||||
}
|
||||
|
||||
module_init(mimio_init);
|
||||
module_exit(mimio_exit);
|
||||
|
||||
MODULE_AUTHOR(DRIVER_AUTHOR);
|
||||
MODULE_DESCRIPTION(DRIVER_DESC);
|
||||
MODULE_LICENSE("GPL");
|
||||
Loading…
Reference in a new issue