drivers/input/misc/vsense.c

   1 /*
   2         vsense.c
   3
   4         Written by Gražvydas Ignotas <notasas@gmail.com>
   5
   6         This program is free software; you can redistribute it and/or modify
   7         it under the terms of the GNU General Public License as published by
   8         the Free Software Foundation; version 2 of the License.
   9 */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/module.h>
  14 #include <linux/i2c.h>
  15 #include <linux/input.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/timer.h>
  18 #include <linux/uaccess.h>
  19 #include <linux/ctype.h>
  20 #include <linux/proc_fs.h>
  21 #include <linux/idr.h>
  22 #include <linux/i2c/vsense.h>
  23 #include <linux/gpio.h>
  24 #include <linux/regulator/consumer.h>
  25
  26 #define VSENSE_INTERVAL         25
  27
  28 #define VSENSE_MODE_ABS         0
  29 #define VSENSE_MODE_MOUSE       1
  30 #define VSENSE_MODE_SCROLL      2
  31 #define VSENSE_MODE_MBUTTONS    3
  32
  33 static DEFINE_IDR(vsense_proc_id);
  34 static DEFINE_MUTEX(vsense_mutex);
  35
  36 /* Reset state is shared between both nubs, so we keep
  37  * track of it here.
  38  */
  39 static int vsense_reset_state;
  40 static int vsense_reset_refcount;
  41
  42 struct vsense_drvdata {
  43         char dev_name[12];
  44         struct input_dev *input;
  45         struct i2c_client *client;
  46         struct regulator *reg;
  47         struct delayed_work work;
  48         int reset_gpio;
  49         int irq_gpio;
  50         int mode;
  51         int proc_id;
  52         struct proc_dir_entry *proc_root;
  53         int mouse_multiplier;   /* 24.8 */
  54         int scrollx_multiplier;
  55         int scrolly_multiplier;
  56         int scroll_counter;
  57         int scroll_steps;
  58         struct {
  59                 int threshold_x;
  60                 int threshold_y;
  61                 int delay;
  62                 int dblclick_stage;
  63                 int state_l;
  64                 int state_m;
  65                 int state_r;
  66                 int pos_active;
  67                 int pos_prev;
  68                 int pos_stable_counter;
  69         } mbutton;
  70 };
  71
  72 enum nub_position {
  73         NUB_POS_CENTER = 0,
  74         NUB_POS_UP,
  75         NUB_POS_RIGHT,
  76         NUB_POS_DOWN,
  77         NUB_POS_LEFT,
  78 };
  79
  80 static void release_mbuttons(struct vsense_drvdata *ddata)
  81 {
  82         if (ddata->mbutton.state_l) {
  83                 input_report_key(ddata->input, BTN_LEFT, 0);
  84                 ddata->mbutton.state_l = 0;
  85         }
  86         if (ddata->mbutton.state_m) {
  87                 input_report_key(ddata->input, BTN_MIDDLE, 0);
  88                 ddata->mbutton.state_m = 0;
  89         }
  90         if (ddata->mbutton.state_r) {
  91                 input_report_key(ddata->input, BTN_RIGHT, 0);
  92                 ddata->mbutton.state_r = 0;
  93         }
  94         ddata->mbutton.pos_active = NUB_POS_CENTER;
  95 }
  96
  97 static void vsense_work(struct work_struct *work)
  98 {
  99         struct vsense_drvdata *ddata;
 100         int ax = 0, ay = 0, rx = 0, ry = 0;
 101         int update_pending = 0;
 102         signed char buff[4];
 103         int ret, pos, l, m, r;
 104
 105         ddata = container_of(work, struct vsense_drvdata, work.work);
 106
 107         if (unlikely(gpio_get_value(ddata->irq_gpio)))
 108                 goto dosync;
 109
 110         ret = i2c_master_recv(ddata->client, buff, sizeof(buff));
 111         if (unlikely(ret != sizeof(buff))) {
 112                 dev_err(&ddata->client->dev, "read failed with %i\n", ret);
 113                 goto dosync;
 114         }
 115
 116         rx = (signed int)buff[0];
 117         ry = (signed int)buff[1];
 118         ax = (signed int)buff[2];
 119         ay = (signed int)buff[3];
 120
 121         schedule_delayed_work(&ddata->work, msecs_to_jiffies(VSENSE_INTERVAL));
 122         update_pending = 1;
 123
 124 dosync:
 125         switch (ddata->mode) {
 126         case VSENSE_MODE_MOUSE:
 127                 rx = rx * ddata->mouse_multiplier / 256;
 128                 ry = -ry * ddata->mouse_multiplier / 256;
 129                 input_report_rel(ddata->input, REL_X, rx);
 130                 input_report_rel(ddata->input, REL_Y, ry);
 131                 break;
 132         case VSENSE_MODE_SCROLL:
 133                 if (++(ddata->scroll_counter) < ddata->scroll_steps)
 134                         return;
 135                 ddata->scroll_counter = 0;
 136                 ax = ax * ddata->scrollx_multiplier / 256;
 137                 ay = ay * ddata->scrolly_multiplier / 256;
 138                 input_report_rel(ddata->input, REL_HWHEEL, ax);
 139                 input_report_rel(ddata->input, REL_WHEEL, ay);
 140                 break;
 141         case VSENSE_MODE_MBUTTONS:
 142                 if (!update_pending) {
 143                         release_mbuttons(ddata);
 144                         break;
 145                 }
 146
 147                 pos = NUB_POS_CENTER;
 148                 if      (ax >= ddata->mbutton.threshold_x) pos = NUB_POS_RIGHT;
 149                 else if (ax <= -ddata->mbutton.threshold_x) pos = NUB_POS_LEFT;
 150                 else if (ay >= ddata->mbutton.threshold_y) pos = NUB_POS_UP;
 151                 else if (ay <= -ddata->mbutton.threshold_y) pos = NUB_POS_DOWN;
 152
 153                 if (pos != ddata->mbutton.pos_prev) {
 154                         ddata->mbutton.pos_prev = pos;
 155                         ddata->mbutton.pos_stable_counter = 0;
 156                 }
 157                 else
 158                         ddata->mbutton.pos_stable_counter++;
 159
 160                 if (ddata->mbutton.pos_stable_counter < ddata->mbutton.delay)
 161                         pos = ddata->mbutton.pos_active;
 162
 163                 if (pos != NUB_POS_UP)
 164                         ddata->mbutton.dblclick_stage = 0;
 165
 166                 l = m = r = 0;
 167                 switch (pos) {
 168                 case NUB_POS_UP:
 169                         ddata->mbutton.dblclick_stage++;
 170                         switch (ddata->mbutton.dblclick_stage) {
 171                                 case 1: case 2: case 5: case 6:
 172                                 l = 1;
 173                                 break;
 174                         }
 175                         break;
 176                 case NUB_POS_RIGHT:
 177                         r = 1;
 178                         break;
 179                 case NUB_POS_DOWN:
 180                         m = 1;
 181                         break;
 182                 case NUB_POS_LEFT:
 183                         l = 1;
 184                         break;
 185                 }
 186                 input_report_key(ddata->input, BTN_LEFT, l);
 187                 input_report_key(ddata->input, BTN_RIGHT, r);
 188                 input_report_key(ddata->input, BTN_MIDDLE, m);
 189                 ddata->mbutton.pos_active = pos;
 190                 ddata->mbutton.state_l = l;
 191                 ddata->mbutton.state_m = m;
 192                 ddata->mbutton.state_r = r;
 193                 break;
 194         default:
 195                 input_report_abs(ddata->input, ABS_X, ax * 8);
 196                 input_report_abs(ddata->input, ABS_Y, -ay * 8);
 197                 break;
 198         }
 199         input_sync(ddata->input);
 200 }
 201
 202 static irqreturn_t vsense_isr(int irq, void *dev_id)
 203 {
 204         struct vsense_drvdata *ddata = dev_id;
 205
 206         schedule_delayed_work(&ddata->work, 0);
 207
 208         return IRQ_HANDLED;
 209 }
 210
 211 static int vsense_reset(struct vsense_drvdata *ddata, int val)
 212 {
 213         int ret;
 214
 215         dev_dbg(&ddata->client->dev, "vsense_reset: %i\n", val);
 216
 217         if (ddata->mode != VSENSE_MODE_ABS)
 218                 release_mbuttons(ddata);
 219
 220         ret = gpio_direction_output(ddata->reset_gpio, val);
 221         if (ret < 0) {
 222                 dev_err(&ddata->client->dev, "failed to configure direction "
 223                         "for GPIO %d, error %d\n", ddata->reset_gpio, ret);
 224         }
 225         else {
 226                 vsense_reset_state = val;
 227         }
 228
 229         return ret;
 230 }
 231
 232 static int vsense_open(struct input_dev *dev)
 233 {
 234         dev_dbg(&dev->dev, "vsense_open\n");
 235
 236         /* get out of reset and stay there until user wants to reset it */
 237         if (vsense_reset_state != 0)
 238                 vsense_reset(input_get_drvdata(dev), 0);
 239
 240         return 0;
 241 }
 242
 243 static int vsense_input_register(struct vsense_drvdata *ddata, int mode)
 244 {
 245         struct input_dev *input;
 246         int ret;
 247
 248         input = input_allocate_device();
 249         if (input == NULL)
 250                 return -ENOMEM;
 251
 252         if (mode != VSENSE_MODE_ABS) {
 253                 /* pretend to be a mouse */
 254                 input_set_capability(input, EV_REL, REL_X);
 255                 input_set_capability(input, EV_REL, REL_Y);
 256                 input_set_capability(input, EV_REL, REL_WHEEL);
 257                 input_set_capability(input, EV_REL, REL_HWHEEL);
 258                 /* add fake buttons to fool X that this is a mouse */
 259                 input_set_capability(input, EV_KEY, BTN_LEFT);
 260                 input_set_capability(input, EV_KEY, BTN_RIGHT);
 261                 input_set_capability(input, EV_KEY, BTN_MIDDLE);
 262         } else {
 263                 input->evbit[BIT_WORD(EV_ABS)] = BIT_MASK(EV_ABS);
 264                 input_set_abs_params(input, ABS_X, -256, 256, 0, 0);
 265                 input_set_abs_params(input, ABS_Y, -256, 256, 0, 0);
 266         }
 267
 268         input->name = ddata->dev_name;
 269         input->dev.parent = &ddata->client->dev;
 270
 271         input->id.bustype = BUS_I2C;
 272         input->id.version = 0x0092;
 273
 274         input->open = vsense_open;
 275
 276         ddata->input = input;
 277         input_set_drvdata(input, ddata);
 278
 279         ret = input_register_device(input);
 280         if (ret) {
 281                 dev_err(&ddata->client->dev, "failed to register input device,"
 282                         " error %d\n", ret);
 283                 input_free_device(input);
 284                 return ret;
 285         }
 286
 287         return 0;
 288 }
 289
 290 static void vsense_input_unregister(struct vsense_drvdata *ddata)
 291 {
 292         cancel_delayed_work_sync(&ddata->work);
 293         input_unregister_device(ddata->input);
 294 }
 295
 296 static int vsense_proc_mode_read(char *page, char **start, off_t off, int count,
 297                 int *eof, void *data)
 298 {
 299         struct vsense_drvdata *ddata = data;
 300         char *p = page;
 301         int len;
 302
 303         switch (ddata->mode) {
 304         case VSENSE_MODE_MOUSE:
 305                 len = sprintf(p, "mouse\n");
 306                 break;
 307         case VSENSE_MODE_SCROLL:
 308                 len = sprintf(p, "scroll\n");
 309                 break;
 310         case VSENSE_MODE_MBUTTONS:
 311                 len = sprintf(p, "mbuttons\n");
 312                 break;
 313         default:
 314                 len = sprintf(p, "absolute\n");
 315                 break;
 316         }
 317
 318         *eof = 1;
 319         return len;
 320 }
 321
 322 static int vsense_proc_mode_write(struct file *file, const char __user *buffer,
 323                 unsigned long count, void *data)
 324 {
 325         struct vsense_drvdata *ddata = data;
 326         int mode = ddata->mode;
 327         char buff[32], *p;
 328         int ret;
 329
 330         count = strncpy_from_user(buff, buffer,
 331                         count < sizeof(buff) ? count : sizeof(buff) - 1);
 332         buff[count] = 0;
 333
 334         p = buff + strlen(buff) - 1;
 335         while (p > buff && isspace(*p))
 336                 p--;
 337         p[1] = 0;
 338
 339         if (strcasecmp(buff, "mouse") == 0)
 340                 mode = VSENSE_MODE_MOUSE;
 341         else if (strcasecmp(buff, "scroll") == 0)
 342                 mode = VSENSE_MODE_SCROLL;
 343         else if (strcasecmp(buff, "mbuttons") == 0)
 344                 mode = VSENSE_MODE_MBUTTONS;
 345         else if (strcasecmp(buff, "absolute") == 0)
 346                 mode = VSENSE_MODE_ABS;
 347         else {
 348                 dev_err(&ddata->client->dev, "unknown mode: %s\n", buff);
 349                 return -EINVAL;
 350         }
 351
 352         if (ddata->mode != VSENSE_MODE_ABS)
 353                 release_mbuttons(ddata);
 354
 355         if ((mode == VSENSE_MODE_ABS && ddata->mode != VSENSE_MODE_ABS) ||
 356             (mode != VSENSE_MODE_ABS && ddata->mode == VSENSE_MODE_ABS)) {
 357                 disable_irq(ddata->client->irq);
 358                 vsense_input_unregister(ddata);
 359                 ret = vsense_input_register(ddata, mode);
 360                 if (ret)
 361                         dev_err(&ddata->client->dev, "failed to re-register "
 362                                 "input as %d, code %d\n", mode, ret);
 363                 else
 364                         enable_irq(ddata->client->irq);
 365         }
 366         ddata->mode = mode;
 367
 368         return count;
 369 }
 370
 371 static int vsense_proc_int_read(char *page, char **start, off_t off,
 372                 int count, int *eof, void *data)
 373 {
 374         int *val = data;
 375         int len;
 376
 377         len = sprintf(page, "%d\n", *val);
 378         *eof = 1;
 379         return len;
 380 }
 381
 382 static int vsense_proc_int_write(struct file *file, const char __user *buffer,
 383                 unsigned long count, void *data)
 384 {
 385         char buff[32];
 386         long val;
 387         int ret;
 388         int *value = data;
 389
 390         count = strncpy_from_user(buff, buffer,
 391                         count < sizeof(buff) ? count : sizeof(buff) - 1);
 392         buff[count] = 0;
 393
 394         ret = strict_strtol(buff, 0, &val);
 395         if (ret < 0)
 396                 return ret;
 397         *value = val;
 398         return count;
 399 }
 400
 401 static int vsense_proc_mult_read(char *page, char **start, off_t off,
 402                 int count, int *eof, void *data)
 403 {
 404         int *multiplier = data;
 405         int val = *multiplier * 100 / 256;
 406         return vsense_proc_int_read(page, start, off, count, eof, &val);
 407 }
 408
 409 static int vsense_proc_mult_write(struct file *file, const char __user *buffer,
 410                 unsigned long count, void *data)
 411 {
 412         int *multiplier = data;
 413         int ret, val, adj;
 414
 415         ret = vsense_proc_int_write(file, buffer, count, &val);
 416         if (ret < 0)
 417                 return ret;
 418         if (val == 0)
 419                 return -EINVAL;
 420
 421         /* round to higher absolute value */
 422         adj = val < 0 ? -99 : 99;
 423         *multiplier = (val * 256 + adj) / 100;
 424
 425         return ret;
 426 }
 427
 428 static int vsense_proc_rate_read(char *page, char **start, off_t off,
 429                 int count, int *eof, void *data)
 430 {
 431         int *steps = data;
 432         int val = 1000 / VSENSE_INTERVAL / *steps;
 433         return vsense_proc_int_read(page, start, off, count, eof, &val);
 434 }
 435
 436 static int vsense_proc_rate_write(struct file *file, const char __user *buffer,
 437                 unsigned long count, void *data)
 438 {
 439         int *steps = data;
 440         int ret, val;
 441
 442         ret = vsense_proc_int_write(file, buffer, count, &val);
 443         if (ret < 0)
 444                 return ret;
 445         if (val < 1)
 446                 return -EINVAL;
 447
 448         *steps = 1000 / VSENSE_INTERVAL / val;
 449         if (*steps < 1)
 450                 *steps = 1;
 451         return ret;
 452 }
 453
 454 static int vsense_proc_treshold_write(struct file *file, const char __user *buffer,
 455                 unsigned long count, void *data)
 456 {
 457         int *value = data;
 458         int ret, val;
 459
 460         ret = vsense_proc_int_write(file, buffer, count, &val);
 461         if (ret < 0)
 462                 return ret;
 463         if (val < 1 || val > 32)
 464                 return -EINVAL;
 465
 466         *value = val;
 467         return ret;
 468 }
 469
 470 static ssize_t
 471 vsense_show_reset(struct device *dev, struct device_attribute *attr, char *buf)
 472 {
 473         return sprintf(buf, "%d\n", vsense_reset_state);
 474 }
 475
 476 static ssize_t
 477 vsense_set_reset(struct device *dev, struct device_attribute *attr,
 478                 const char *buf, size_t count)
 479 {
 480         unsigned long new_reset;
 481         struct i2c_client *client;
 482         struct vsense_drvdata *ddata;
 483         int ret;
 484
 485         ret = strict_strtoul(buf, 10, &new_reset);
 486         if (ret)
 487                 return -EINVAL;
 488
 489         client = to_i2c_client(dev);
 490         ddata = i2c_get_clientdata(client);
 491
 492         vsense_reset(ddata, new_reset ? 1 : 0);
 493
 494         return count;
 495 }
 496 static DEVICE_ATTR(reset, S_IRUGO | S_IWUSR,
 497         vsense_show_reset, vsense_set_reset);
 498
 499 static void vsense_create_proc(struct vsense_drvdata *ddata,
 500                                void *pdata, const char *name,
 501                                read_proc_t *read_proc, write_proc_t *write_proc)
 502 {
 503         struct proc_dir_entry *pret;
 504
 505         pret = create_proc_entry(name, S_IWUGO | S_IRUGO, ddata->proc_root);
 506         if (pret == NULL) {
 507                 dev_err(&ddata->client->dev, "failed to create proc file %s\n", name);
 508                 return;
 509         }
 510
 511         pret->data = pdata;
 512         pret->read_proc = read_proc;
 513         pret->write_proc = write_proc;
 514 }
 515
 516 static int vsense_probe(struct i2c_client *client,
 517                          const struct i2c_device_id *id)
 518 {
 519         struct vsense_platform_data *pdata = client->dev.platform_data;
 520         struct vsense_drvdata *ddata;
 521         char buff[32];
 522         int ret;
 523
 524         if (pdata == NULL) {
 525                 dev_err(&client->dev, "no platform data?\n");
 526                 return -EINVAL;
 527         }
 528
 529         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) {
 530                 dev_err(&client->dev, "can't talk I2C?\n");
 531                 return -EIO;
 532         }
 533
 534         ddata = kzalloc(sizeof(struct vsense_drvdata), GFP_KERNEL);
 535         if (ddata == NULL)
 536                 return -ENOMEM;
 537
 538         ret = idr_pre_get(&vsense_proc_id, GFP_KERNEL);
 539         if (ret == 0) {
 540                 ret = -ENOMEM;
 541                 goto err_idr;
 542         }
 543
 544         mutex_lock(&vsense_mutex);
 545
 546         ret = idr_get_new(&vsense_proc_id, client, &ddata->proc_id);
 547         if (ret < 0) {
 548                 mutex_unlock(&vsense_mutex);
 549                 goto err_idr;
 550         }
 551
 552         if (!vsense_reset_refcount) {
 553                 ret = gpio_request_one(pdata->gpio_reset, GPIOF_OUT_INIT_HIGH,
 554                         "vsense reset");
 555                 if (ret < 0) {
 556                         dev_err(&client->dev, "gpio_request error: %d, %d\n",
 557                                 pdata->gpio_reset, ret);
 558                         mutex_unlock(&vsense_mutex);
 559                         goto err_gpio_reset;
 560                 }
 561         }
 562         vsense_reset_refcount++;
 563
 564         mutex_unlock(&vsense_mutex);
 565
 566         ret = gpio_request_one(pdata->gpio_irq, GPIOF_IN, client->name);
 567         if (ret < 0) {
 568                 dev_err(&client->dev, "failed to request GPIO %d,"
 569                         " error %d\n", pdata->gpio_irq, ret);
 570                 goto err_gpio_irq;
 571         }
 572
 573         ret = gpio_to_irq(pdata->gpio_irq);
 574         if (ret < 0) {
 575                 dev_err(&client->dev, "unable to get irq number for GPIO %d, "
 576                         "error %d\n", pdata->gpio_irq, ret);
 577                 goto err_gpio_to_irq;
 578         }
 579         client->irq = ret;
 580
 581         snprintf(ddata->dev_name, sizeof(ddata->dev_name),
 582                  "nub%d", ddata->proc_id);
 583
 584         INIT_DELAYED_WORK(&ddata->work, vsense_work);
 585         ddata->mode = VSENSE_MODE_ABS;
 586         ddata->client = client;
 587         ddata->reset_gpio = pdata->gpio_reset;
 588         ddata->irq_gpio = pdata->gpio_irq;
 589         ddata->mouse_multiplier = 170 * 256 / 100;
 590         ddata->scrollx_multiplier =
 591         ddata->scrolly_multiplier = 8 * 256 / 100;
 592         ddata->scroll_steps = 1000 / VSENSE_INTERVAL / 3;
 593         ddata->mbutton.threshold_x = 20;
 594         ddata->mbutton.threshold_y = 26;
 595         ddata->mbutton.delay = 1;
 596         i2c_set_clientdata(client, ddata);
 597
 598         ddata->reg = regulator_get(&client->dev, "vcc");
 599         if (IS_ERR(ddata->reg)) {
 600                 ret = PTR_ERR(ddata->reg);
 601                 dev_err(&client->dev, "unable to get regulator: %d\n", ret);
 602                 goto err_regulator_get;
 603         }
 604
 605         ret = regulator_enable(ddata->reg);
 606         if (ret) {
 607                 dev_err(&client->dev, "unable to enable regulator: %d\n", ret);
 608                 goto err_regulator_enable;
 609         }
 610
 611         /* HACK */
 612         if (vsense_reset_refcount == 2)
 613                 /* resetting drains power, as well as disabling supply,
 614                  * so keep it powered and out of reset at all times */
 615                 vsense_reset(ddata, 0);
 616
 617         ret = vsense_input_register(ddata, ddata->mode);
 618         if (ret) {
 619                 dev_err(&client->dev, "failed to register input device, "
 620                         "error %d\n", ret);
 621                 goto err_input_register;
 622         }
 623
 624         ret = request_irq(client->irq, vsense_isr,
 625                         IRQF_SAMPLE_RANDOM | IRQF_TRIGGER_FALLING,
 626                         client->name, ddata);
 627         if (ret) {
 628                 dev_err(&client->dev, "unable to claim irq %d, error %d\n",
 629                         client->irq, ret);
 630                 goto err_request_irq;
 631         }
 632
 633         dev_dbg(&client->dev, "probe %02x, gpio %i, irq %i, \"%s\"\n",
 634                 client->addr, pdata->gpio_irq, client->irq, client->name);
 635
 636         snprintf(buff, sizeof(buff), "pandora/nub%d", ddata->proc_id);
 637         ddata->proc_root = proc_mkdir(buff, NULL);
 638         if (ddata->proc_root != NULL) {
 639                 vsense_create_proc(ddata, ddata, "mode",
 640                                 vsense_proc_mode_read, vsense_proc_mode_write);
 641                 vsense_create_proc(ddata, &ddata->mouse_multiplier, "mouse_sensitivity",
 642                                 vsense_proc_mult_read, vsense_proc_mult_write);
 643                 vsense_create_proc(ddata, &ddata->scrollx_multiplier, "scrollx_sensitivity",
 644                                 vsense_proc_mult_read, vsense_proc_mult_write);
 645                 vsense_create_proc(ddata, &ddata->scrolly_multiplier, "scrolly_sensitivity",
 646                                 vsense_proc_mult_read, vsense_proc_mult_write);
 647                 vsense_create_proc(ddata, &ddata->scroll_steps, "scroll_rate",
 648                                 vsense_proc_rate_read, vsense_proc_rate_write);
 649                 vsense_create_proc(ddata, &ddata->mbutton.threshold_x, "mbutton_threshold",
 650                                 vsense_proc_int_read, vsense_proc_treshold_write);
 651                 vsense_create_proc(ddata, &ddata->mbutton.threshold_y, "mbutton_threshold_y",
 652                                 vsense_proc_int_read, vsense_proc_treshold_write);
 653                 vsense_create_proc(ddata, &ddata->mbutton.delay, "mbutton_delay",
 654                                 vsense_proc_int_read, vsense_proc_int_write);
 655         } else
 656                 dev_err(&client->dev, "can't create proc dir");
 657
 658         ret = device_create_file(&client->dev, &dev_attr_reset);
 659
 660         return 0;
 661
 662 err_request_irq:
 663         vsense_input_unregister(ddata);
 664 err_input_register:
 665 err_regulator_enable:
 666         regulator_put(ddata->reg);
 667 err_regulator_get:
 668 err_gpio_to_irq:
 669         gpio_free(pdata->gpio_irq);
 670 err_gpio_irq:
 671         gpio_free(pdata->gpio_reset);
 672 err_gpio_reset:
 673         idr_remove(&vsense_proc_id, ddata->proc_id);
 674 err_idr:
 675         kfree(ddata);
 676         return ret;
 677 }
 678
 679 static int __devexit vsense_remove(struct i2c_client *client)
 680 {
 681         struct vsense_drvdata *ddata;
 682         char buff[32];
 683
 684         dev_dbg(&client->dev, "remove\n");
 685
 686         ddata = i2c_get_clientdata(client);
 687
 688         mutex_lock(&vsense_mutex);
 689
 690         vsense_reset_refcount--;
 691         if (!vsense_reset_refcount)
 692                 gpio_free(ddata->reset_gpio);
 693
 694         mutex_unlock(&vsense_mutex);
 695
 696         device_remove_file(&client->dev, &dev_attr_reset);
 697
 698         remove_proc_entry("mode", ddata->proc_root);
 699         remove_proc_entry("mouse_sensitivity", ddata->proc_root);
 700         remove_proc_entry("scrollx_sensitivity", ddata->proc_root);
 701         remove_proc_entry("scrolly_sensitivity", ddata->proc_root);
 702         remove_proc_entry("scroll_rate", ddata->proc_root);
 703         remove_proc_entry("mbutton_threshold", ddata->proc_root);
 704         remove_proc_entry("mbutton_threshold_y", ddata->proc_root);
 705         remove_proc_entry("mbutton_delay", ddata->proc_root);
 706         snprintf(buff, sizeof(buff), "pandora/nub%d", ddata->proc_id);
 707         remove_proc_entry(buff, NULL);
 708         idr_remove(&vsense_proc_id, ddata->proc_id);
 709
 710         free_irq(client->irq, ddata);
 711         vsense_input_unregister(ddata);
 712         gpio_free(ddata->irq_gpio);
 713         regulator_put(ddata->reg);
 714         kfree(ddata);
 715
 716         return 0;
 717 }
 718
 719 #ifdef CONFIG_PM_SLEEP
 720 static int vsense_i2c_suspend(struct device *dev)
 721 {
 722         struct i2c_client *client = to_i2c_client(dev);
 723         struct vsense_drvdata *ddata = i2c_get_clientdata(client);
 724
 725         /* we can't process irqs while i2c is suspended and we can't
 726          * ask the device to not generate them, so just disable instead */
 727         cancel_delayed_work_sync(&ddata->work);
 728         disable_irq(client->irq);
 729
 730         return 0;
 731 }
 732
 733 static int vsense_i2c_resume(struct device *dev)
 734 {
 735         struct i2c_client *client = to_i2c_client(dev);
 736
 737         enable_irq(client->irq);
 738
 739         return 0;
 740 }
 741 #endif /* CONFIG_PM_SLEEP */
 742
 743 static SIMPLE_DEV_PM_OPS(vsense_pm_ops, vsense_i2c_suspend, vsense_i2c_resume);
 744
 745 static const struct i2c_device_id vsense_id[] = {
 746         { "vsense", 0 },
 747         { }
 748 };
 749
 750 static struct i2c_driver vsense_driver = {
 751         .driver = {
 752                 .name   = "vsense",
 753                 .owner  = THIS_MODULE,
 754                 .pm     = &vsense_pm_ops,
 755         },
 756         .probe          = vsense_probe,
 757         .remove         = __devexit_p(vsense_remove),
 758         .id_table       = vsense_id,
 759 };
 760
 761 static int __init vsense_init(void)
 762 {
 763         return i2c_add_driver(&vsense_driver);
 764 }
 765
 766 static void __exit vsense_exit(void)
 767 {
 768         i2c_del_driver(&vsense_driver);
 769 }
 770
 771
 772 MODULE_AUTHOR("Grazvydas Ignotas");
 773 MODULE_DESCRIPTION("VSense navigation device driver");
 774 MODULE_LICENSE("GPL");
 775
 776 module_init(vsense_init);
 777 module_exit(vsense_exit);