git.oblomov.eu Git - linux-2.6/blob - drivers/staging/mimio/mimio.c

   1 /*
   2  * Hardware event => input event mapping:
   3  *
   4  *
   5  *
   6  input.h:#define BTN_TOOL_PEN            0x140 black
   7  input.h:#define BTN_TOOL_RUBBER         0x141 blue
   8  input.h:#define BTN_TOOL_BRUSH          0x142 green
   9  input.h:#define BTN_TOOL_PENCIL         0x143 red
  10  input.h:#define BTN_TOOL_AIRBRUSH       0x144 eraser
  11  input.h:#define BTN_TOOL_FINGER         0x145 small eraser
  12  input.h:#define BTN_TOOL_MOUSE          0x146 mimio interactive
  13  input.h:#define BTN_TOOL_LENS           0x147 mimio interactive but1
  14  input.h:#define LOCALBTN_TOOL_EXTRA1    0x14a mimio interactive but2 == BTN_TOUCH
  15  input.h:#define LOCALBTN_TOOL_EXTRA2    0x14b mimio extra pens (orange, brown, yellow, purple) == BTN_STYLUS
  16  input.h:#define LOCALBTN_TOOL_EXTRA3    0x14c unused == BTN_STYLUS2
  17  input.h:#define BTN_TOOL_DOUBLETAP      0x14d unused
  18  input.h:#define BTN_TOOL_TRIPLETAP      0x14e unused
  19  *
  20  * MIMIO_EV_PENDOWN(MIMIO_PEN_K)     => EV_KEY BIT(BTN_TOOL_PEN)
  21  * MIMIO_EV_PENDOWN(MIMIO_PEN_B)     => EV_KEY BIT(BTN_TOOL_RUBBER)
  22  * MIMIO_EV_PENDOWN(MIMIO_PEN_G)     => EV_KEY BIT(BTN_TOOL_BRUSH)
  23  * MIMIO_EV_PENDOWN(MIMIO_PEN_R)     => EV_KEY BIT(BTN_TOOL_PENCIL)
  24  * MIMIO_EV_PENDOWN(MIMIO_PEN_E)     => EV_KEY BIT(BTN_TOOL_AIRBRUSH)
  25  * MIMIO_EV_PENDOWN(MIMIO_PEN_ES)    => EV_KEY BIT(BTN_TOOL_FINGER)
  26  * MIMIO_EV_PENDOWN(MIMIO_PEN_I)     => EV_KEY BIT(BTN_TOOL_MOUSE)
  27  * MIMIO_EV_PENDOWN(MIMIO_PEN_IL)    => EV_KEY BIT(BTN_TOOL_LENS)
  28  * MIMIO_EV_PENDOWN(MIMIO_PEN_IR)    => EV_KEY BIT(BTN_TOOL_DOUBLETAP)
  29  * MIMIO_EV_PENDOWN(MIMIO_PEN_EX)    => EV_KEY BIT(BTN_TOOL_TRIPLETAP)
  30  * MIMIO_EV_PENDATA                 => EV_ABS BIT(ABS_X), BIT(ABS_Y)
  31  * MIMIO_EV_MEMRESET              => EV_KEY BIT(BTN_0)
  32  * MIMIO_EV_ACC(ACC_NEWPAGE)       => EV_KEY BIT(BTN_1)
  33  * MIMIO_EV_ACC(ACC_TAGPAGE)      => EV_KEY BIT(BTN_2)
  34  * MIMIO_EV_ACC(ACC_PRINTPAGE)      => EV_KEY BIT(BTN_3)
  35  * MIMIO_EV_ACC(ACC_MAXIMIZE)      => EV_KEY BIT(BTN_4)
  36  * MIMIO_EV_ACC(ACC_FINDCTLPNL)      => EV_KEY BIT(BTN_5)
  37  *
  38  *
  39  * open issues:
  40  *      - cold-load of data captured when mimio in standalone mode not yet
  41  *         supported; need to snoop Win32 box to see datastream for this.
  42  *       - mimio mouse not yet supported; need to snoop Win32 box to see the
  43  *         datastream for this.
  44  */
  45 #include <linux/kernel.h>
  46 #include <linux/init.h>
  47 #include <linux/slab.h>
  48 #include <linux/spinlock.h>
  49 #include <linux/input.h>
  50 #include <linux/usb.h>
  51
  52 #define DRIVER_VERSION          "v0.031"
  53 #define DRIVER_AUTHOR           "mwilder@cs.nmsu.edu"
  54 #define DRIVER_DESC             "USB mimio-xi driver"
  55
  56 enum {UPVALUE, DOWNVALUE, MOVEVALUE};
  57
  58 #define MIMIO_XRANGE_MAX        9600
  59 #define MIMIO_YRANGE_MAX        4800
  60
  61 #define LOCALBTN_TOOL_EXTRA1    BTN_TOUCH
  62 #define LOCALBTN_TOOL_EXTRA2    BTN_STYLUS
  63 #define LOCALBTN_TOOL_EXTRA3    BTN_STYLUS2
  64
  65 #define MIMIO_VENDOR_ID         0x08d3
  66 #define MIMIO_PRODUCT_ID        0x0001
  67 #define MIMIO_MAXPAYLOAD        (8)
  68 #define MIMIO_MAXNAMELEN        (64)
  69 #define MIMIO_TXWAIT            (1)
  70 #define MIMIO_TXDONE            (2)
  71
  72 #define MIMIO_EV_PENDOWN        (0x22)
  73 #define MIMIO_EV_PENDATA        (0x24)
  74 #define MIMIO_EV_PENUP          (0x51)
  75 #define MIMIO_EV_MEMRESET       (0x45)
  76 #define MIMIO_EV_ACC            (0xb2)
  77
  78 #define MIMIO_PEN_K             (1)     /* black pen */
  79 #define MIMIO_PEN_B             (2)     /* blue pen */
  80 #define MIMIO_PEN_G             (3)     /* green pen */
  81 #define MIMIO_PEN_R             (4)     /* red pen */
  82 /* 5, 6, 7, 8 are extra pens */
  83 #define MIMIO_PEN_E             (9)     /* big eraser */
  84 #define MIMIO_PEN_ES            (10)    /* lil eraser */
  85 #define MIMIO_PENJUMP_START     (10)
  86 #define MIMIO_PENJUMP           (6)
  87 #define MIMIO_PEN_I             (17)    /* mimio interactive */
  88 #define MIMIO_PEN_IL            (18)    /* mimio interactive button 1 */
  89 #define MIMIO_PEN_IR            (19)    /* mimio interactive button 2 */
  90
  91 #define MIMIO_PEN_MAX           (MIMIO_PEN_IR)
  92
  93 #define ACC_DONE                (0)
  94 #define ACC_NEWPAGE             (1)
  95 #define ACC_TAGPAGE             (2)
  96 #define ACC_PRINTPAGE           (4)
  97 #define ACC_MAXIMIZE            (8)
  98 #define ACC_FINDCTLPNL          (16)
  99
 100 #define isvalidtxsize(n)        ((n) > 0 && (n) <= MIMIO_MAXPAYLOAD)
 101
 102
 103 struct pktbuf {
 104         unsigned char instr;
 105         unsigned char buf[16];
 106         unsigned char *p;
 107         unsigned char *q;
 108 };
 109
 110 struct usbintendpt {
 111         dma_addr_t dma;
 112         struct urb *urb;
 113         unsigned char *buf;
 114         struct usb_endpoint_descriptor *desc;
 115 };
 116
 117 struct mimio {
 118         struct input_dev *idev;
 119         struct usb_device *udev;
 120         struct usb_interface *uifc;
 121         int open;
 122         int present;
 123         int greeted;
 124         int txflags;
 125         char phys[MIMIO_MAXNAMELEN];
 126         struct usbintendpt in;
 127         struct usbintendpt out;
 128         struct pktbuf pktbuf;
 129         unsigned char minor;
 130         wait_queue_head_t waitq;
 131         spinlock_t txlock;
 132         void (*rxhandler)(struct mimio *, unsigned char *, unsigned int);
 133         int last_pen_down;
 134 };
 135
 136 static void mimio_close(struct input_dev *);
 137 static void mimio_dealloc(struct mimio *);
 138 static void mimio_disconnect(struct usb_interface *);
 139 static int mimio_greet(struct mimio *);
 140 static void mimio_irq_in(struct urb *);
 141 static void mimio_irq_out(struct urb *);
 142 static int mimio_open(struct input_dev *);
 143 static int mimio_probe(struct usb_interface *, const struct usb_device_id *);
 144 static void mimio_rx_handler(struct mimio *, unsigned char *, unsigned int);
 145 static int mimio_tx(struct mimio *, const char *, int);
 146
 147 static char mimio_name[] = "VirtualInk mimio-Xi";
 148 static struct usb_device_id mimio_table [] = {
 149         { USB_DEVICE(MIMIO_VENDOR_ID, MIMIO_PRODUCT_ID) },
 150         { USB_DEVICE(0x0525, 0xa4a0) }, /* gadget zero firmware */
 151         { }
 152 };
 153
 154 MODULE_DEVICE_TABLE(usb, mimio_table);
 155
 156 static struct usb_driver mimio_driver = {
 157         .name = "mimio",
 158         .probe = mimio_probe,
 159         .disconnect = mimio_disconnect,
 160         .id_table = mimio_table,
 161 };
 162
 163 static DECLARE_MUTEX(disconnect_sem);
 164
 165 static void mimio_close(struct input_dev *idev)
 166 {
 167         struct mimio *mimio;
 168
 169         mimio = input_get_drvdata(idev);
 170         if (!mimio) {
 171                 dev_err(&idev->dev, "null mimio attached to input device\n");
 172                 return;
 173         }
 174
 175         if (mimio->open <= 0)
 176                 dev_err(&idev->dev, "mimio not open.\n");
 177         else
 178                 mimio->open--;
 179
 180         if (mimio->present == 0 && mimio->open == 0)
 181                 mimio_dealloc(mimio);
 182 }
 183
 184 static void mimio_dealloc(struct mimio *mimio)
 185 {
 186         if (mimio == NULL)
 187                 return;
 188
 189         usb_kill_urb(mimio->in.urb);
 190
 191         usb_kill_urb(mimio->out.urb);
 192
 193         if (mimio->idev) {
 194                 input_unregister_device(mimio->idev);
 195                 if (mimio->idev->grab)
 196                         input_close_device(mimio->idev->grab);
 197                 else
 198                         dev_dbg(&mimio->idev->dev, "mimio->idev->grab == NULL"
 199                                 " -- didn't call input_close_device\n");
 200         }
 201
 202         usb_free_urb(mimio->in.urb);
 203
 204         usb_free_urb(mimio->out.urb);
 205
 206         if (mimio->in.buf) {
 207                 usb_buffer_free(mimio->udev, MIMIO_MAXPAYLOAD, mimio->in.buf,
 208                                 mimio->in.dma);
 209         }
 210
 211         if (mimio->out.buf)
 212                 usb_buffer_free(mimio->udev, MIMIO_MAXPAYLOAD, mimio->out.buf,
 213                                 mimio->out.dma);
 214
 215         if (mimio->idev)
 216                 input_free_device(mimio->idev);
 217
 218         kfree(mimio);
 219 }
 220
 221 static void mimio_disconnect(struct usb_interface *ifc)
 222 {
 223         struct mimio *mimio;
 224
 225         down(&disconnect_sem);
 226
 227         mimio = usb_get_intfdata(ifc);
 228         usb_set_intfdata(ifc, NULL);
 229         dev_dbg(&mimio->idev->dev, "disconnect\n");
 230
 231         if (mimio) {
 232                 mimio->present = 0;
 233
 234                 if (mimio->open <= 0)
 235                         mimio_dealloc(mimio);
 236         }
 237
 238         up(&disconnect_sem);
 239 }
 240
 241 static int mimio_greet(struct mimio *mimio)
 242 {
 243         const struct grtpkt {
 244                 int nbytes;
 245                 unsigned delay;
 246                 char data[8];
 247         } grtpkts[] = {
 248                 { 3, 0, { 0x11, 0x55, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00 } },
 249                 { 5, 0, { 0x53, 0x55, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00 } },
 250                 { 5, 0, { 0x43, 0x55, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00 } },
 251                 { 5, 0, { 0x33, 0x55, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00 } },
 252                 { 5, 0, { 0x13, 0x00, 0x5e, 0x02, 0x4f, 0x00, 0x00, 0x00 } },
 253                 { 5, 0, { 0x13, 0x00, 0x04, 0x03, 0x14, 0x00, 0x00, 0x00 } },
 254                 { 5, 2, { 0x13, 0x00, 0x00, 0x04, 0x17, 0x00, 0x00, 0x00 } },
 255                 { 5, 0, { 0x13, 0x00, 0x0d, 0x08, 0x16, 0x00, 0x00, 0x00 } },
 256                 { 5, 0, { 0x13, 0x00, 0x4d, 0x01, 0x5f, 0x00, 0x00, 0x00 } },
 257                 { 3, 0, { 0xf1, 0x55, 0xa4, 0x00, 0x00, 0x00, 0x00, 0x00 } },
 258                 { 7, 2, { 0x52, 0x55, 0x00, 0x07, 0x31, 0x55, 0x64, 0x00 } },
 259                 { 0, 0, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
 260         };
 261         int rslt;
 262         const struct grtpkt *pkt;
 263
 264         for (pkt = grtpkts; pkt->nbytes; pkt++) {
 265                 rslt = mimio_tx(mimio, pkt->data, pkt->nbytes);
 266                 if (rslt)
 267                         return rslt;
 268                 if (pkt->delay)
 269                         msleep(pkt->delay);
 270         }
 271
 272         return 0;
 273 }
 274
 275 static void mimio_irq_in(struct urb *urb)
 276 {
 277         int rslt;
 278         char *data;
 279         const char *reason = "going down";
 280         struct mimio *mimio;
 281
 282         mimio = urb->context;
 283
 284         if (mimio == NULL)
 285                 /* paranoia */
 286                 return;
 287
 288         switch (urb->status) {
 289         case 0:
 290                 /* success */
 291                 break;
 292         case -ETIMEDOUT:
 293                 reason = "timeout -- unplugged?";
 294         case -ECONNRESET:
 295         case -ENOENT:
 296         case -ESHUTDOWN:
 297                 dev_dbg(&mimio->idev->dev, "%s.\n", reason);
 298                 return;
 299         default:
 300                 dev_dbg(&mimio->idev->dev, "unknown urb-status: %d.\n",
 301                         urb->status);
 302                 goto exit;
 303         }
 304         data = mimio->in.buf;
 305
 306         if (mimio->rxhandler)
 307                 mimio->rxhandler(mimio, data, urb->actual_length);
 308 exit:
 309         /*
 310          * Keep listening to device on same urb.
 311          */
 312         rslt = usb_submit_urb(urb, GFP_ATOMIC);
 313         if (rslt)
 314                 dev_err(&mimio->idev->dev, "usb_submit_urb failure: %d.\n",
 315                         rslt);
 316 }
 317
 318 static void mimio_irq_out(struct urb *urb)
 319 {
 320         unsigned long flags;
 321         struct mimio *mimio;
 322
 323         mimio = urb->context;
 324
 325         if (urb->status)
 326                 dev_dbg(&mimio->idev->dev, "urb-status: %d.\n", urb->status);
 327
 328         spin_lock_irqsave(&mimio->txlock, flags);
 329         mimio->txflags |= MIMIO_TXDONE;
 330         spin_unlock_irqrestore(&mimio->txlock, flags);
 331         wmb();
 332         wake_up(&mimio->waitq);
 333 }
 334
 335 static int mimio_open(struct input_dev *idev)
 336 {
 337         int rslt;
 338         struct mimio *mimio;
 339
 340         rslt = 0;
 341         down(&disconnect_sem);
 342         mimio = input_get_drvdata(idev);
 343         dev_dbg(&idev->dev, "mimio_open\n");
 344
 345         if (mimio == NULL) {
 346                 dev_err(&idev->dev, "null mimio.\n");
 347                 rslt = -ENODEV;
 348                 goto exit;
 349         }
 350
 351         if (mimio->open++)
 352                 goto exit;
 353
 354         if (mimio->present && !mimio->greeted) {
 355                 struct urb *urb = mimio->in.urb;
 356                 mimio->in.urb->dev = mimio->udev;
 357                 rslt = usb_submit_urb(mimio->in.urb, GFP_KERNEL);
 358                 if (rslt) {
 359                         dev_err(&idev->dev, "usb_submit_urb failure "
 360                                 "(res = %d: %s). Not greeting.\n",
 361                                 rslt,
 362                                 (!urb ? "urb is NULL" :
 363                                  (urb->hcpriv ? "urb->hcpriv is non-NULL" :
 364                                   (!urb->complete ? "urb is not complete" :
 365                                    (urb->number_of_packets <= 0 ? "urb has no packets" :
 366                                     (urb->interval <= 0 ? "urb interval too small" :
 367                                      "urb interval too large or some other error"))))));
 368                         rslt = -EIO;
 369                         goto exit;
 370                 }
 371                 rslt = mimio_greet(mimio);
 372                 if (rslt == 0) {
 373                         dev_dbg(&idev->dev, "Mimio greeted OK.\n");
 374                         mimio->greeted = 1;
 375                 } else {
 376                         dev_dbg(&idev->dev, "Mimio greet Failure (%d)\n",
 377                                 rslt);
 378                 }
 379         }
 380
 381 exit:
 382         up(&disconnect_sem);
 383         return rslt;
 384 }
 385
 386 static int mimio_probe(struct usb_interface *ifc,
 387                        const struct usb_device_id *id)
 388 {
 389         char path[64];
 390         int pipe, maxp;
 391         struct mimio *mimio;
 392         struct usb_device *udev;
 393         struct usb_host_interface *hostifc;
 394         struct input_dev *input_dev;
 395         int res = 0;
 396         int i;
 397
 398         udev = interface_to_usbdev(ifc);
 399
 400         mimio = kzalloc(sizeof(struct mimio), GFP_KERNEL);
 401         if (!mimio)
 402                 return -ENOMEM;
 403
 404         input_dev = input_allocate_device();
 405         if (!input_dev) {
 406                 mimio_dealloc(mimio);
 407                 return -ENOMEM;
 408         }
 409
 410         mimio->uifc = ifc;
 411         mimio->udev = udev;
 412         mimio->pktbuf.p = mimio->pktbuf.buf;
 413         mimio->pktbuf.q = mimio->pktbuf.buf;
 414         /* init_input_dev(mimio->idev); */
 415         mimio->idev = input_dev;
 416         init_waitqueue_head(&mimio->waitq);
 417         spin_lock_init(&mimio->txlock);
 418         hostifc = ifc->cur_altsetting;
 419
 420         if (hostifc->desc.bNumEndpoints != 2) {
 421                 dev_err(&udev->dev, "Unexpected endpoint count: %d.\n",
 422                         hostifc->desc.bNumEndpoints);
 423                 mimio_dealloc(mimio);
 424                 return -ENODEV;
 425         }
 426
 427         mimio->in.desc = &(hostifc->endpoint[0].desc);
 428         mimio->out.desc = &(hostifc->endpoint[1].desc);
 429
 430         mimio->in.buf = usb_buffer_alloc(udev, MIMIO_MAXPAYLOAD, GFP_KERNEL,
 431                                          &mimio->in.dma);
 432         mimio->out.buf = usb_buffer_alloc(udev, MIMIO_MAXPAYLOAD, GFP_KERNEL,
 433                                           &mimio->out.dma);
 434
 435         if (mimio->in.buf == NULL || mimio->out.buf == NULL) {
 436                 dev_err(&udev->dev, "usb_buffer_alloc failure.\n");
 437                 mimio_dealloc(mimio);
 438                 return -ENOMEM;
 439         }
 440
 441         mimio->in.urb = usb_alloc_urb(0, GFP_KERNEL);
 442         mimio->out.urb = usb_alloc_urb(0, GFP_KERNEL);
 443
 444         if (mimio->in.urb == NULL || mimio->out.urb == NULL) {
 445                 dev_err(&udev->dev, "usb_alloc_urb failure.\n");
 446                 mimio_dealloc(mimio);
 447                 return -ENOMEM;
 448         }
 449
 450         /*
 451          * Build the input urb.
 452          */
 453         pipe = usb_rcvintpipe(udev, mimio->in.desc->bEndpointAddress);
 454         maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
 455         if (maxp > MIMIO_MAXPAYLOAD)
 456                 maxp = MIMIO_MAXPAYLOAD;
 457         usb_fill_int_urb(mimio->in.urb, udev, pipe, mimio->in.buf, maxp,
 458                          mimio_irq_in, mimio, mimio->in.desc->bInterval);
 459         mimio->in.urb->transfer_dma = mimio->in.dma;
 460         mimio->in.urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 461
 462         /*
 463          * Build the output urb.
 464          */
 465         pipe = usb_sndintpipe(udev, mimio->out.desc->bEndpointAddress);
 466         maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
 467         if (maxp > MIMIO_MAXPAYLOAD)
 468                 maxp = MIMIO_MAXPAYLOAD;
 469         usb_fill_int_urb(mimio->out.urb, udev, pipe, mimio->out.buf, maxp,
 470                          mimio_irq_out, mimio, mimio->out.desc->bInterval);
 471         mimio->out.urb->transfer_dma = mimio->out.dma;
 472         mimio->out.urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 473
 474         /*
 475          * Build input device info
 476          */
 477         usb_make_path(udev, path, 64);
 478         snprintf(mimio->phys, MIMIO_MAXNAMELEN, "%s/input0", path);
 479         input_set_drvdata(input_dev, mimio);
 480         /* input_dev->dev = &ifc->dev; */
 481         input_dev->open = mimio_open;
 482         input_dev->close = mimio_close;
 483         input_dev->name = mimio_name;
 484         input_dev->phys = mimio->phys;
 485         input_dev->dev.parent = &ifc->dev;
 486
 487         input_dev->id.bustype = BUS_USB;
 488         input_dev->id.vendor = le16_to_cpu(udev->descriptor.idVendor);
 489         input_dev->id.product = le16_to_cpu(udev->descriptor.idProduct);
 490         input_dev->id.version = le16_to_cpu(udev->descriptor.bcdDevice);
 491
 492         input_dev->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS);
 493         for (i = BTN_TOOL_PEN; i <= LOCALBTN_TOOL_EXTRA2; ++i)
 494                 set_bit(i, input_dev->keybit);
 495
 496         input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_0) |
 497                                                  BIT_MASK(BTN_1) |
 498                                                  BIT_MASK(BTN_2) |
 499                                                  BIT_MASK(BTN_3) |
 500                                                  BIT_MASK(BTN_4) |
 501                                                  BIT_MASK(BTN_5);
 502         /*   input_dev->keybit[BTN_MOUSE] |= BIT(BTN_LEFT); */
 503         input_dev->absbit[0] |= BIT_MASK(ABS_X) | BIT_MASK(ABS_Y);
 504         input_set_abs_params(input_dev, ABS_X, 0, MIMIO_XRANGE_MAX, 0, 0);
 505         input_set_abs_params(input_dev, ABS_Y, 0, MIMIO_YRANGE_MAX, 0, 0);
 506         input_dev->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
 507
 508 #if 0
 509         input_dev->absmin[ABS_X] = 0;
 510         input_dev->absmin[ABS_Y] = 0;
 511         input_dev->absmax[ABS_X] = 9600;
 512         input_dev->absmax[ABS_Y] = 4800;
 513         input_dev->absfuzz[ABS_X] = 0;
 514         input_dev->absfuzz[ABS_Y] = 0;
 515         input_dev->absflat[ABS_X] = 0;
 516         input_dev->absflat[ABS_Y] = 0;
 517 #endif
 518
 519 #if 0
 520         /* this will just reduce the precision */
 521         input_dev->absfuzz[ABS_X] = 8; /* experimental; may need to change */
 522         input_dev->absfuzz[ABS_Y] = 8; /* experimental; may need to change */
 523 #endif
 524
 525         /*
 526          * Register the input device.
 527          */
 528         res = input_register_device(mimio->idev);
 529         if (res) {
 530                 dev_err(&udev->dev, "input_register_device failure (%d)\n",
 531                         res);
 532                 mimio_dealloc(mimio);
 533                 return -EIO;
 534         }
 535         dev_dbg(&mimio->idev->dev, "input: %s on %s (res = %d).\n",
 536                 input_dev->name, input_dev->phys, res);
 537
 538         usb_set_intfdata(ifc, mimio);
 539         mimio->present = 1;
 540
 541         /*
 542          * Submit the input urb to the usb subsystem.
 543          */
 544         mimio->in.urb->dev = mimio->udev;
 545         res = usb_submit_urb(mimio->in.urb, GFP_KERNEL);
 546         if (res) {
 547                 dev_err(&mimio->idev->dev, "usb_submit_urb failure (%d)\n",
 548                         res);
 549                 mimio_dealloc(mimio);
 550                 return -EIO;
 551         }
 552
 553         /*
 554          * Attempt to greet the mimio after giving
 555          * it some post-init settling time.
 556          *
 557          * note: sometimes this sleep interval isn't
 558          * long enough to permit the device to re-init
 559          * after a hot-swap; maybe need to bump it up.
 560          *
 561          * As it is, this probably breaks module unloading support!
 562          */
 563         msleep(1024);
 564
 565         res = mimio_greet(mimio);
 566         if (res == 0) {
 567                 dev_dbg(&mimio->idev->dev, "Mimio greeted OK.\n");
 568                 mimio->greeted = 1;
 569                 mimio->rxhandler = mimio_rx_handler;
 570         } else {
 571                 dev_dbg(&mimio->idev->dev, "Mimio greet Failure (%d)\n", res);
 572         }
 573
 574         return 0;
 575 }
 576
 577 static int handle_mimio_rx_penupdown(struct mimio *mimio,
 578                                      int down,
 579                                      const char *const instr[],
 580                                      const int instr_ofst[])
 581 {
 582         int penid, x;
 583         if (mimio->pktbuf.q - mimio->pktbuf.p < (down ? 4 : 3))
 584                 return 1;               /* partial pkt */
 585
 586         if (down) {
 587                 x = *mimio->pktbuf.p ^ *(mimio->pktbuf.p + 1) ^
 588                         *(mimio->pktbuf.p + 2);
 589                 if (x != *(mimio->pktbuf.p + 3)) {
 590                         dev_dbg(&mimio->idev->dev, "EV_PEN%s: bad xsum.\n",
 591                                 down ? "DOWN":"UP");
 592                         /* skip this event data */
 593                         mimio->pktbuf.p += 4;
 594                         /* decode any remaining events */
 595                         return 0;
 596                 }
 597                 penid = mimio->pktbuf.instr = *(mimio->pktbuf.p + 2);
 598                 if (penid > MIMIO_PEN_MAX) {
 599                         dev_dbg(&mimio->idev->dev,
 600                                 "Unmapped penID (not in [0, %d]): %d\n",
 601                                 MIMIO_PEN_MAX, (int)mimio->pktbuf.instr);
 602                         penid = mimio->pktbuf.instr = 0;
 603                 }
 604                 mimio->last_pen_down = penid;
 605         } else {
 606                 penid = mimio->last_pen_down;
 607         }
 608         dev_dbg(&mimio->idev->dev, "%s (id %d, code %d) %s.\n", instr[penid],
 609                 instr_ofst[penid], penid, down ? "down" : "up");
 610
 611         if (instr_ofst[penid] >= 0) {
 612                 int code = BTN_TOOL_PEN + instr_ofst[penid];
 613                 int value = down ? DOWNVALUE : UPVALUE;
 614                 if (code > KEY_MAX)
 615                         dev_dbg(&mimio->idev->dev, "input_event will ignore "
 616                                 "-- code (%d) > KEY_MAX\n", code);
 617                 if (!test_bit(code, mimio->idev->keybit))
 618                         dev_dbg(&mimio->idev->dev, "input_event will ignore "
 619                                 "-- bit for code (%d) not enabled\n", code);
 620                 if (!!test_bit(code, mimio->idev->key) == value)
 621                         dev_dbg(&mimio->idev->dev, "input_event will ignore "
 622                                 "-- bit for code (%d) already set to %d\n",
 623                                 code, value);
 624                 if (value != DOWNVALUE) {
 625                         /* input_regs(mimio->idev, regs); */
 626                         input_report_key(mimio->idev, code, value);
 627                         input_sync(mimio->idev);
 628                 } else {
 629                         /* wait until we get some coordinates */
 630                 }
 631         } else {
 632                 dev_dbg(&mimio->idev->dev, "penID offset[%d] == %d is < 0 "
 633                         "- not sending\n", penid, instr_ofst[penid]);
 634         }
 635         mimio->pktbuf.p += down ? 4 : 3; /* 3 for up, 4 for down */
 636         return 0;
 637 }
 638
 639 /*
 640  * Stay tuned for partial-packet excitement.
 641  *
 642  * This routine buffers data packets received from the mimio device
 643  * in the mimio's data space.  This buffering is necessary because
 644  * the mimio's in endpoint can serve us partial packets of data, and
 645  * we want the driver to support the servicing of multiple mimios.
 646  * Empirical evidence gathered so far suggests that the method of
 647  * buffering packet data in the mimio's data space works.  Previous
 648  * versions of this driver did not buffer packet data in each mimio's
 649  * data-space, and were therefore not able to service multiple mimios.
 650  * Note that since the caller of this routine is running in interrupt
 651  * context, care needs to be taken to ensure that this routine does not
 652  * become bloated, and it may be that another spinlock is needed in each
 653  * mimio to guard the buffered packet data properly.
 654  */
 655 static void mimio_rx_handler(struct mimio *mimio,
 656                              unsigned char *data,
 657                              unsigned int nbytes)
 658 {
 659         struct device *dev = &mimio->idev->dev;
 660         unsigned int x;
 661         unsigned int y;
 662         static const char * const instr[] = {
 663                 "?0",
 664                 "black pen", "blue pen", "green pen", "red pen",
 665                 "brown pen", "orange pen", "purple pen", "yellow pen",
 666                 "big eraser", "lil eraser",
 667                 "?11", "?12", "?13", "?14", "?15", "?16",
 668                 "mimio interactive", "interactive button1",
 669                 "interactive button2"
 670         };
 671
 672         /* Mimio Interactive gives:
 673          * down: [0x22 0x01 0x11 0x32 0x24]
 674          * b1  : [0x22 0x01 0x12 0x31 0x24]
 675          * b2  : [0x22 0x01 0x13 0x30 0x24]
 676          */
 677         static const int instr_ofst[] = {
 678                 -1,
 679                 0, 1, 2, 3,
 680                 9, 9, 9, 9,
 681                 4, 5,
 682                 -1, -1, -1, -1, -1, -1,
 683                 6, 7, 8,
 684         };
 685
 686         memcpy(mimio->pktbuf.q, data, nbytes);
 687         mimio->pktbuf.q += nbytes;
 688
 689         while (mimio->pktbuf.p < mimio->pktbuf.q) {
 690                 int t = *mimio->pktbuf.p;
 691                 switch (t) {
 692                 case MIMIO_EV_PENUP:
 693                 case MIMIO_EV_PENDOWN:
 694                         if (handle_mimio_rx_penupdown(mimio,
 695                                                       t == MIMIO_EV_PENDOWN,
 696                                                       instr, instr_ofst))
 697                                 return; /* partial packet */
 698                         break;
 699
 700                 case MIMIO_EV_PENDATA:
 701                         if (mimio->pktbuf.q - mimio->pktbuf.p < 6)
 702                                 /* partial pkt */
 703                                 return;
 704                         x = *mimio->pktbuf.p ^ *(mimio->pktbuf.p + 1) ^
 705                                 *(mimio->pktbuf.p + 2) ^
 706                                 *(mimio->pktbuf.p + 3) ^
 707                                 *(mimio->pktbuf.p + 4);
 708                         if (x != *(mimio->pktbuf.p + 5)) {
 709                                 dev_dbg(dev, "EV_PENDATA: bad xsum.\n");
 710                                 mimio->pktbuf.p += 6; /* skip this event data */
 711                                 break; /* decode any remaining events */
 712                         }
 713                         x = *(mimio->pktbuf.p + 1);
 714                         x <<= 8;
 715                         x |= *(mimio->pktbuf.p + 2);
 716                         y = *(mimio->pktbuf.p + 3);
 717                         y <<= 8;
 718                         y |= *(mimio->pktbuf.p + 4);
 719                         dev_dbg(dev, "coord: (%d, %d)\n", x, y);
 720                         if (instr_ofst[mimio->pktbuf.instr] >= 0) {
 721                                 int code = BTN_TOOL_PEN +
 722                                            instr_ofst[mimio->last_pen_down];
 723 #if 0
 724                                 /* Utter hack to ensure we get forwarded _AND_
 725                                  * so we can identify when a complete signal is
 726                                  * received */
 727                                 mimio->idev->abs[ABS_Y] = -1;
 728                                 mimio->idev->abs[ABS_X] = -1;
 729 #endif
 730                                 /* input_regs(mimio->idev, regs); */
 731                                 input_report_abs(mimio->idev, ABS_X, x);
 732                                 input_report_abs(mimio->idev, ABS_Y, y);
 733                                 /* fake a penup */
 734                                 change_bit(code, mimio->idev->key);
 735                                 input_report_key(mimio->idev,
 736                                                  code,
 737                                                  DOWNVALUE);
 738                                 /* always sync here */
 739                                 mimio->idev->sync = 0;
 740                                 input_sync(mimio->idev);
 741                         }
 742                         mimio->pktbuf.p += 6;
 743                         break;
 744                 case MIMIO_EV_MEMRESET:
 745                         if (mimio->pktbuf.q - mimio->pktbuf.p < 7)
 746                                 /* partial pkt */
 747                                 return;
 748                         dev_dbg(dev, "mem-reset.\n");
 749                         /* input_regs(mimio->idev, regs); */
 750                         input_event(mimio->idev, EV_KEY, BTN_0, 1);
 751                         input_event(mimio->idev, EV_KEY, BTN_0, 0);
 752                         input_sync(mimio->idev);
 753                         mimio->pktbuf.p += 7;
 754                         break;
 755                 case MIMIO_EV_ACC:
 756                         if (mimio->pktbuf.q - mimio->pktbuf.p < 4)
 757                                 /* partial pkt */
 758                                 return;
 759                         x = *mimio->pktbuf.p ^ *(mimio->pktbuf.p + 1) ^
 760                                 *(mimio->pktbuf.p + 2);
 761                         if (x != *(mimio->pktbuf.p + 3)) {
 762                                 dev_dbg(dev, "EV_ACC: bad xsum.\n");
 763                                 mimio->pktbuf.p += 4; /* skip this event data */
 764                                 break; /* decode any remaining events */
 765                         }
 766                         switch (*(mimio->pktbuf.p + 2)) {
 767                         case ACC_NEWPAGE:
 768                                 dev_dbg(&mimio->idev->dev, "new-page.\n");
 769                                 /* input_regs(mimio->idev, regs); */
 770                                 input_event(mimio->idev, EV_KEY, BTN_1, 1);
 771                                 input_event(mimio->idev, EV_KEY, BTN_1, 0);
 772                                 input_sync(mimio->idev);
 773                                 break;
 774                         case ACC_TAGPAGE:
 775                                 dev_dbg(&mimio->idev->dev, "tag-page.\n");
 776                                 /* input_regs(mimio->idev, regs); */
 777                                 input_event(mimio->idev, EV_KEY, BTN_2, 1);
 778                                 input_event(mimio->idev, EV_KEY, BTN_2, 0);
 779                                 input_sync(mimio->idev);
 780                                 break;
 781                         case ACC_PRINTPAGE:
 782                                 dev_dbg(&mimio->idev->dev, "print-page.\n");
 783                                 /* input_regs(mimio->idev, regs);*/
 784                                 input_event(mimio->idev, EV_KEY, BTN_3, 1);
 785                                 input_event(mimio->idev, EV_KEY, BTN_3, 0);
 786                                 input_sync(mimio->idev);
 787                                 break;
 788                         case ACC_MAXIMIZE:
 789                                 dev_dbg(&mimio->idev->dev,
 790                                         "maximize-window.\n");
 791                                 /* input_regs(mimio->idev, regs); */
 792                                 input_event(mimio->idev, EV_KEY, BTN_4, 1);
 793                                 input_event(mimio->idev, EV_KEY, BTN_4, 0);
 794                                 input_sync(mimio->idev);
 795                                 break;
 796                         case ACC_FINDCTLPNL:
 797                                 dev_dbg(&mimio->idev->dev, "find-ctl-panel.\n");
 798                                 /* input_regs(mimio->idev, regs); */
 799                                 input_event(mimio->idev, EV_KEY, BTN_5, 1);
 800                                 input_event(mimio->idev, EV_KEY, BTN_5, 0);
 801                                 input_sync(mimio->idev);
 802                                 break;
 803                         case ACC_DONE:
 804                                 dev_dbg(&mimio->idev->dev, "acc-done.\n");
 805                                 /* no event is dispatched to the input
 806                                  * subsystem for this device event.
 807                                  */
 808                                 break;
 809                         default:
 810                                 dev_dbg(dev, "unknown acc event.\n");
 811                                 break;
 812                         }
 813                         mimio->pktbuf.p += 4;
 814                         break;
 815                 default:
 816                         mimio->pktbuf.p++;
 817                         break;
 818                 }
 819         }
 820
 821         /*
 822          * No partial event was received, so reset mimio's pktbuf ptrs.
 823          */
 824         mimio->pktbuf.p = mimio->pktbuf.q = mimio->pktbuf.buf;
 825 }
 826
 827 static int mimio_tx(struct mimio *mimio, const char *buf, int nbytes)
 828 {
 829         int rslt;
 830         int timeout;
 831         unsigned long flags;
 832         DECLARE_WAITQUEUE(wait, current);
 833
 834         if (!(isvalidtxsize(nbytes))) {
 835                 dev_err(&mimio->idev->dev, "invalid arg: nbytes: %d.\n",
 836                         nbytes);
 837                 return -EINVAL;
 838         }
 839
 840         /*
 841          * Init the out urb and copy the data to send.
 842          */
 843         mimio->out.urb->dev = mimio->udev;
 844         mimio->out.urb->transfer_buffer_length = nbytes;
 845         memcpy(mimio->out.urb->transfer_buffer, buf, nbytes);
 846
 847         /*
 848          * Send the data.
 849          */
 850         spin_lock_irqsave(&mimio->txlock, flags);
 851         mimio->txflags = MIMIO_TXWAIT;
 852         rslt = usb_submit_urb(mimio->out.urb, GFP_ATOMIC);
 853         spin_unlock_irqrestore(&mimio->txlock, flags);
 854         dev_dbg(&mimio->idev->dev, "rslt: %d.\n", rslt);
 855
 856         if (rslt) {
 857                 dev_err(&mimio->idev->dev, "usb_submit_urb failure: %d.\n",
 858                         rslt);
 859                 return rslt;
 860         }
 861
 862         /*
 863          * Wait for completion to be signalled (the mimio_irq_out
 864          * completion routine will or MIMIO_TXDONE in with txflags).
 865          */
 866         timeout = HZ;
 867         set_current_state(TASK_INTERRUPTIBLE);
 868         add_wait_queue(&mimio->waitq, &wait);
 869
 870         while (timeout && ((mimio->txflags & MIMIO_TXDONE) == 0)) {
 871                 timeout = schedule_timeout(timeout);
 872                 rmb();
 873         }
 874
 875         if ((mimio->txflags & MIMIO_TXDONE) == 0)
 876                 dev_dbg(&mimio->idev->dev, "tx timed out.\n");
 877
 878         /*
 879          * Now that completion has been signalled,
 880          * unlink the urb so that it can be recycled.
 881          */
 882         set_current_state(TASK_RUNNING);
 883         remove_wait_queue(&mimio->waitq, &wait);
 884         usb_unlink_urb(mimio->out.urb);
 885
 886         return rslt;
 887 }
 888
 889 static int __init mimio_init(void)
 890 {
 891         int rslt;
 892
 893         rslt = usb_register(&mimio_driver);
 894         if (rslt != 0) {
 895                 err("%s: usb_register failure: %d", __func__, rslt);
 896                 return rslt;
 897         }
 898
 899         printk(KERN_INFO KBUILD_MODNAME ":"
 900                DRIVER_DESC " " DRIVER_VERSION "\n");
 901         return rslt;
 902 }
 903
 904 static void __exit mimio_exit(void)
 905 {
 906         usb_deregister(&mimio_driver);
 907 }
 908
 909 module_init(mimio_init);
 910 module_exit(mimio_exit);
 911
 912 MODULE_AUTHOR(DRIVER_AUTHOR);
 913 MODULE_DESCRIPTION(DRIVER_DESC);
 914 MODULE_LICENSE("GPL");