drivers/sensor/gp2ap002a00f.c

   1 /*
   2  * Copyright (C) 2011 Sony Ericsson Mobile Communications Inc.
   3  *
   4  * Author: Courtney Cavin <courtney.cavin@sonyericsson.com>
   5  * Prepared for up-stream by: Oskar Andero <oskar.andero@sonyericsson.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2, as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/i2c.h>
  13 #include <linux/irq.h>
  14 #include <linux/fs.h>
  15 #include <linux/uaccess.h>
  16 #include <linux/slab.h>
  17 #include <linux/input.h>
  18 #include <linux/module.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/gpio.h>
  21 #include <linux/delay.h>
  22 #include <linux/gp2ap002a00f.h>
  23 #include <linux/sensors_core.h>
  24
  25 static struct device *proximity_sensor_device = NULL;
  26
  27 #define OFFSET_FILE_PATH        "/efs/prox_cal"
  28
  29
  30 #define PROX_NONDETECT  0x2F
  31 #define PROX_DETECT             0x0C
  32
  33 #define PROX_NONDETECT_MODE1    0x43
  34 #define PROX_DETECT_MODE1               0x28
  35
  36 #define PROX_NONDETECT_MODE2    0x48
  37 #define PROX_DETECT_MODE2               0x42
  38
  39 struct gp2a_data {
  40         struct input_dev *input;
  41         const struct gp2a_platform_data *pdata;
  42         struct i2c_client *i2c_client;
  43         int proximity_enabled;
  44         int irq;
  45         int value;
  46
  47         char cal_mode;
  48
  49 };
  50
  51 static int nondetect;
  52 static int detect;
  53
  54
  55 enum gp2a_addr {
  56         GP2A_ADDR_PROX  = 0x0,
  57         GP2A_ADDR_GAIN  = 0x1,
  58         GP2A_ADDR_HYS   = 0x2,
  59         GP2A_ADDR_CYCLE = 0x3,
  60         GP2A_ADDR_OPMOD = 0x4,
  61         GP2A_ADDR_CON   = 0x6
  62 };
  63
  64 enum gp2a_controls {
  65         /* Software Shutdown control: 0 = shutdown, 1 = normal operation */
  66         GP2A_CTRL_SSD   = 0x01
  67 };
  68
  69 static int gp2a_report(struct gp2a_data *dt)
  70 {
  71         int vo = gpio_get_value(dt->pdata->vout_gpio);
  72
  73         dt->value = vo;
  74
  75         input_report_switch(dt->input, SW_FRONT_PROXIMITY, vo);
  76         input_sync(dt->input);
  77
  78         return 0;
  79 }
  80
  81 static irqreturn_t gp2a_irq(int irq, void *handle)
  82 {
  83         struct gp2a_data *dt = handle;
  84
  85         printk(KERN_EMERG"Proximity Interrupts ::%d\n",irq);
  86
  87         gp2a_report(dt);
  88
  89         return IRQ_HANDLED;
  90 }
  91
  92 static int gp2a_enable(struct gp2a_data *dt)
  93 {
  94         return i2c_smbus_write_byte_data(dt->i2c_client, GP2A_ADDR_OPMOD,
  95                                          GP2A_CTRL_SSD);
  96 }
  97
  98 static int gp2a_disable(struct gp2a_data *dt)
  99 {
 100         return i2c_smbus_write_byte_data(dt->i2c_client, GP2A_ADDR_OPMOD,
 101                                          0x00);
 102 }
 103
 104
 105 /*Only One Read Only register, so word address need not be specified (from Data Sheet)*/
 106 static int gp2a_i2c_read(u8 reg, u8 *value,struct gp2a_data *gp2a_cal_data)
 107 {
 108         int ret =0;
 109         int count=0;
 110         u8 buf[3];
 111         struct i2c_msg msg[1];
 112
 113         buf[0] = reg;
 114
 115         /*first byte read(buf[0]) is dummy read*/
 116         msg[0].addr = gp2a_cal_data->i2c_client->addr;
 117         msg[0].flags = I2C_M_RD;
 118         msg[0].len = 2;
 119         msg[0].buf = buf;
 120         count = i2c_transfer(gp2a_cal_data->i2c_client->adapter, msg, 1);
 121
 122         if(count < 0)
 123         {
 124                 ret =-1;
 125         }
 126         else
 127         {
 128                 *value = buf[0] << 8 | buf[1];
 129         }
 130
 131         return ret;
 132 }
 133
 134 static int gp2a_i2c_write( u8 reg, u8 *value,struct gp2a_data *gp2a_cal_data)
 135 {
 136     int ret =0;
 137     int count=0;
 138     struct i2c_msg msg[1];
 139     u8 data[2];
 140
 141         printk(KERN_INFO "[GP2A] %s : start \n", __func__);
 142
 143     if( (gp2a_cal_data->i2c_client == NULL) || (!gp2a_cal_data->i2c_client->adapter) ){
 144         return -ENODEV;
 145     }
 146
 147     data[0] = reg;
 148     data[1] = *value;
 149
 150     msg[0].addr = gp2a_cal_data->i2c_client->addr;
 151     msg[0].flags = 0;
 152     msg[0].len = 2;
 153     msg[0].buf  = data;
 154     count = i2c_transfer(gp2a_cal_data->i2c_client->adapter,msg,1);
 155
 156     if(count < 0)
 157         ret =-1;
 158
 159
 160         printk(KERN_INFO "[GP2A] %s : stop \n", __func__);
 161
 162     return ret;
 163 }
 164
 165 static ssize_t proximity_enable_show(struct device *dev,
 166         struct device_attribute *attr, char *buf)
 167 {
 168         struct gp2a_data *dt = dev_get_drvdata(dev);
 169
 170         pr_info("%s, %d \n", __func__, __LINE__);
 171         return snprintf(buf, PAGE_SIZE, "%d\n", dt->proximity_enabled);
 172 }
 173
 174 static ssize_t proximity_value_show(struct device *dev,
 175         struct device_attribute *attr, char *buf)
 176 {
 177         struct gp2a_data *dt = dev_get_drvdata(dev);
 178
 179     pr_info("%s, %d \n", __func__, __LINE__);
 180
 181         return snprintf(buf, PAGE_SIZE, "%d\n", dt->value);
 182 }
 183
 184 static ssize_t proximity_enable_store(struct device *dev,
 185         struct device_attribute *attr, const char *buf, size_t count)
 186 {
 187         struct gp2a_data *dt = dev_get_drvdata(dev);
 188
 189         unsigned long value = 0;
 190         int err = 0;
 191
 192         err = strict_strtoul(buf, 10, &value);
 193         if (err)
 194                 pr_err("%s, kstrtoint failed.", __func__);
 195
 196         if (value != 0 && value != 1)
 197                 return count;
 198
 199                 printk(KERN_ALERT"%s :: Request for State(%d->%d)\n",__func__,dt->proximity_enabled,value);
 200
 201         //check for multiple times disable and enable sensor
 202         if (dt->proximity_enabled && !value) {        /* Prox power off */
 203
 204                 disable_irq(dt->irq);
 205
 206                 gp2a_disable(dt);
 207
 208                                 if (dt->pdata->hw_pwr)
 209                                                 dt->pdata->hw_pwr(false);
 210
 211                                 dt->proximity_enabled = 0;
 212         }
 213         if (!dt->proximity_enabled && value) {                  /* prox power on */
 214
 215                                 if (dt->pdata->hw_pwr)
 216                                                 dt->pdata->hw_pwr(true);
 217
 218                 msleep(20);
 219
 220                 gp2a_enable(dt);
 221
 222                                 enable_irq(dt->irq);
 223                                 dt->proximity_enabled = 1;
 224
 225                                 gp2a_report(dt);
 226                 }
 227
 228         return count;
 229 }
 230
 231 static int __init gp2a_initialize(struct gp2a_data *dt)
 232 {
 233         int error;
 234
 235         error = i2c_smbus_write_byte_data(dt->i2c_client, GP2A_ADDR_GAIN,
 236                                           0x08);
 237         if (error < 0)
 238                 return error;
 239
 240         error = i2c_smbus_write_byte_data(dt->i2c_client, GP2A_ADDR_HYS,
 241                                           0xc2);
 242         if (error < 0)
 243                 return error;
 244
 245         error = i2c_smbus_write_byte_data(dt->i2c_client, GP2A_ADDR_CYCLE,
 246                                           0x04);
 247         if (error < 0)
 248                 return error;
 249
 250         error = gp2a_disable(dt);
 251
 252         return error;
 253 }
 254
 255 static int gp2a_prox_offset(unsigned char vout,struct gp2a_data *gp2a_cal_data)
 256 {
 257         u8 reg_value;
 258         int ret=0;
 259
 260         printk(KERN_INFO "[GP2A] %s called\n", __func__);
 261
 262         /* Write HYS Register */
 263         if(!vout)
 264                 reg_value = nondetect;
 265         else
 266                 reg_value = detect;
 267
 268         if((ret=gp2a_i2c_write(GP2A_ADDR_HYS/*0x02*/,&reg_value,gp2a_cal_data))<0)
 269                         printk(KERN_INFO "[GP2A]gp2a_i2c_write 2 failed\n", __func__);
 270
 271         return ret;
 272 }
 273
 274 static int gp2a_prox_cal_mode(char mode,struct gp2a_data *gp2a_cal_data)
 275 {
 276         int ret=0;
 277         u8 reg_value;
 278
 279         printk(KERN_INFO "[GP2A] %s : start \n", __func__);
 280
 281         if (mode == 1)
 282         {
 283                 nondetect = PROX_NONDETECT_MODE1;
 284                 detect = PROX_DETECT_MODE1;
 285         }
 286         else if (mode == 2)
 287         {
 288                 nondetect = PROX_NONDETECT_MODE2;
 289                 detect = PROX_DETECT_MODE2;
 290         }
 291         else
 292         {
 293                 nondetect = PROX_NONDETECT;
 294                 detect = PROX_DETECT;
 295         }
 296
 297
 298         reg_value = 0x08;
 299         if((ret=gp2a_i2c_write(GP2A_ADDR_GAIN/*0x01*/,&reg_value,gp2a_cal_data))<0)
 300                         printk(KERN_INFO "[GP2A]gp2a_i2c_write 1 failed\n", __func__);
 301
 302         gp2a_prox_offset(0,gp2a_cal_data);
 303
 304         reg_value = 0x04;
 305         if((ret=gp2a_i2c_write(GP2A_ADDR_CYCLE/*0x03*/,&reg_value,gp2a_cal_data))<0)
 306                                 printk(KERN_INFO "[GP2A]gp2a_i2c_write 2 failed\n", __func__);
 307
 308         reg_value = 0x03;
 309         if((ret=gp2a_i2c_write(GP2A_ADDR_OPMOD,&reg_value,gp2a_cal_data))<0)
 310                         printk(KERN_INFO "[GP2A]gp2a_i2c_write 3 failed\n", __func__);
 311
 312         reg_value = 0x00;
 313         if((ret=gp2a_i2c_write(GP2A_ADDR_CON,&reg_value,gp2a_cal_data))<0)
 314                         printk(KERN_INFO "[GP2A]gp2a_i2c_write 4 failed\n", __func__);
 315
 316         printk(KERN_INFO "[GP2A] %s : stop \n", __func__);
 317
 318         return ret;
 319
 320 }
 321
 322 static int gp2a_cal_mode_read_file(char *mode,struct gp2a_data *gp2a_cal_data)
 323 {
 324         int err = 0;
 325         mm_segment_t old_fs;
 326         struct file *cal_mode_filp = NULL;
 327
 328         old_fs = get_fs();
 329         set_fs(KERNEL_DS);
 330
 331         cal_mode_filp = filp_open(OFFSET_FILE_PATH, O_RDONLY, 0666);
 332         if (IS_ERR(cal_mode_filp)) {
 333                 printk(KERN_INFO "[GP2A] %s: no cal_mode file\n", __func__);
 334                 err = PTR_ERR(cal_mode_filp);
 335                 if (err != -ENOENT)
 336                         pr_err("[GP2A] %s: Can't open cal_mode file\n", __func__);
 337                 set_fs(old_fs);
 338                 return err;
 339         }
 340         err = cal_mode_filp->f_op->read(cal_mode_filp, mode, sizeof(u8), &cal_mode_filp->f_pos);
 341
 342         if (err != sizeof(u8)) {
 343                 pr_err("%s: Can't read the cal_mode from file\n",       __func__);
 344                 filp_close(cal_mode_filp, current->files);
 345                 set_fs(old_fs);
 346                 return -EIO;
 347         }
 348
 349         filp_close(cal_mode_filp, current->files);
 350         set_fs(old_fs);
 351
 352         return err;
 353 }
 354
 355 static int gp2a_cal_mode_save_file(char mode,struct gp2a_data *gp2a_cal_data)
 356 {
 357         struct file *cal_mode_filp = NULL;
 358         int err = 0;
 359         mm_segment_t old_fs;
 360
 361         printk(KERN_INFO "[GP2A] %s : start \n", __func__);
 362
 363         gp2a_prox_cal_mode(mode,gp2a_cal_data);
 364
 365         old_fs = get_fs();
 366         set_fs(KERNEL_DS);
 367
 368         cal_mode_filp = filp_open(OFFSET_FILE_PATH, O_CREAT | O_TRUNC | O_WRONLY | O_SYNC, 0666);
 369         if (IS_ERR(cal_mode_filp))
 370         {
 371                 pr_err("%s: Can't open cal_mode file\n", __func__);
 372                 set_fs(old_fs);
 373                 err = PTR_ERR(cal_mode_filp);
 374                 pr_err("%s: err = %d\n", __func__, err);
 375                 return err;
 376         }
 377
 378         err = cal_mode_filp->f_op->write(cal_mode_filp, (char *)&mode, sizeof(u8), &cal_mode_filp->f_pos);
 379         if (err != sizeof(u8)) {
 380                 pr_err("%s: Can't read the cal_mode from file\n", __func__);
 381                 err = -EIO;
 382         }
 383         printk(KERN_INFO "[GP2A] %s : stop \n", __func__);
 384
 385         filp_close(cal_mode_filp, current->files);
 386         set_fs(old_fs);
 387
 388         return err;
 389 }
 390 static ssize_t proximity_cal_show(struct device *dev, struct device_attribute *attr, char *buf)
 391 {
 392         int result = 0;
 393
 394         struct gp2a_data *gp2a_cal_data=dev_get_drvdata(dev);
 395
 396
 397         result = gp2a_cal_data->cal_mode;
 398         printk(KERN_INFO "[GP2A] prox_cal_read = %d\n", result);
 399
 400         return sprintf(buf, "%d\n", result);
 401 }
 402
 403 static ssize_t proximity_cal_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
 404 {
 405         struct gp2a_data *gp2a_cal_data=dev_get_drvdata(dev);
 406
 407         if (sysfs_streq(buf, "1"))
 408                 gp2a_cal_data->cal_mode = 1;
 409         else if (sysfs_streq(buf, "2"))
 410                 gp2a_cal_data->cal_mode = 2;
 411         else if (sysfs_streq(buf, "0"))
 412                 gp2a_cal_data->cal_mode = 0;
 413         else  {
 414                 pr_err("[GP2A] %s: invalid value %d\n", __func__, *buf);
 415                 return -EINVAL;
 416         }
 417
 418         printk(KERN_INFO "[GP2A] prox_cal_write =%d\n", gp2a_cal_data->cal_mode);
 419
 420         gp2a_cal_mode_save_file(gp2a_cal_data->cal_mode,gp2a_cal_data);
 421
 422         return size;
 423 }
 424
 425
 426 static DEVICE_ATTR(enable, S_IRUGO|S_IWUSR,
 427         proximity_enable_show, proximity_enable_store);
 428
 429 static DEVICE_ATTR(value, S_IRUGO | S_IWUSR | S_IWGRP,
 430                 proximity_value_show, NULL);
 431
 432 static DEVICE_ATTR(prox_cal, S_IRUGO | S_IWUSR |S_IWGRP|S_IWOTH, proximity_cal_show, proximity_cal_store);
 433
 434 static struct attribute *gp2a_attrs[] = {
 435         &dev_attr_enable.attr,
 436         NULL,
 437 };
 438
 439 static struct attribute_group gp2a_attribute_group = {
 440         .attrs = gp2a_attrs,
 441 };
 442
 443 static struct device_attribute *proximity_sensor_attr[] = {
 444                 &dev_attr_value,
 445                 &dev_attr_enable,
 446
 447                 &dev_attr_prox_cal,
 448
 449                 NULL,
 450  };
 451
 452 static int __init gp2a_probe(struct i2c_client *client,
 453                                 const struct i2c_device_id *id)
 454 {
 455         const struct gp2a_platform_data *pdata = client->dev.platform_data;
 456         struct gp2a_data *dt;
 457         int error;
 458
 459         if (!pdata)
 460                 return -EINVAL;
 461
 462         if (pdata->hw_setup) {
 463                 error = pdata->hw_setup(client);
 464                 if (error < 0)
 465                         return error;
 466         }
 467
 468         error = gpio_request_one(pdata->vout_gpio, GPIOF_IN, GP2A_I2C_NAME);
 469         if (error)
 470                 goto err_hw_shutdown;
 471
 472         dt = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL);
 473         if (!dt) {
 474                 error = -ENOMEM;
 475                 goto err_free_gpio;
 476         }
 477
 478         dt->pdata = pdata;
 479         dt->i2c_client = client;
 480
 481         error = gp2a_initialize(dt);
 482         if (error < 0)
 483                 goto err_free_mem;
 484
 485         dt->input = input_allocate_device();
 486         if (!dt->input) {
 487                 error = -ENOMEM;
 488                 goto err_free_mem;
 489         }
 490
 491         input_set_drvdata(dt->input, dt);
 492
 493 //      dt->input->open = gp2a_device_open;
 494 //      dt->input->close = gp2a_device_close;
 495         dt->input->name = GP2A_I2C_NAME;
 496         dt->input->id.bustype = BUS_I2C;
 497         dt->input->dev.parent = &client->dev;
 498         dt->proximity_enabled = 0;
 499         dt->irq = client->irq;
 500         dt->value = 0;
 501
 502         input_set_capability(dt->input, EV_SW, SW_FRONT_PROXIMITY);
 503
 504         error = request_threaded_irq(client->irq, NULL, gp2a_irq,
 505                         IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
 506                                 IRQF_ONESHOT | IRQF_NO_SUSPEND ,
 507                         GP2A_I2C_NAME, dt);
 508         if (error) {
 509                 dev_err(&client->dev, "irq request failed\n");
 510                 goto err_free_input_dev;
 511         }
 512
 513         error = input_register_device(dt->input);
 514         if (error) {
 515                 dev_err(&client->dev, "device registration failed\n");
 516                 goto err_free_irq;
 517         }
 518
 519         error = sysfs_create_group(&dt->input->dev.kobj, &gp2a_attribute_group);
 520         if (error) {
 521                 dev_err(&client->dev, "sysfs create failed\n");
 522                 goto err_unregister_input;
 523         }
 524
 525         device_init_wakeup(&client->dev, pdata->wakeup);
 526         i2c_set_clientdata(client, dt);
 527         dev_set_drvdata(&client->dev, dt);
 528
 529         error = sensors_register(&proximity_sensor_device, dt,proximity_sensor_attr, "proximity_sensor");
 530
 531         if (error < 0)
 532         {
 533                 pr_err("%s: could not register""proximity sensor device(%d).\n",__func__, error);
 534                 goto err_unregister_input;
 535         }
 536         disable_irq(client->irq);
 537
 538         if (dt->pdata->hw_pwr)
 539         {
 540                         dt->pdata->hw_pwr(false);
 541                         printk(KERN_ALERT"%s :: chip power down\n",__func__);
 542         }
 543         return 0;
 544
 545 err_unregister_input:
 546         input_unregister_device(dt->input);
 547 err_free_irq:
 548         free_irq(client->irq, dt);
 549 err_free_input_dev:
 550         input_free_device(dt->input);
 551 err_free_mem:
 552         kfree(dt);
 553 err_free_gpio:
 554         gpio_free(pdata->vout_gpio);
 555 err_hw_shutdown:
 556         if (pdata->hw_shutdown)
 557                 pdata->hw_shutdown(client);
 558         if (pdata->hw_pwr)
 559                 pdata->hw_pwr(false);
 560         return error;
 561 }
 562
 563 static int __exit gp2a_remove(struct i2c_client *client)
 564 {
 565         struct gp2a_data *dt = i2c_get_clientdata(client);
 566         const struct gp2a_platform_data *pdata = dt->pdata;
 567
 568         device_init_wakeup(&client->dev, false);
 569
 570         free_irq(client->irq, dt);
 571
 572         sensors_unregister(proximity_sensor_device, proximity_sensor_attr);
 573         input_unregister_device(dt->input);
 574         kfree(dt);
 575
 576         gpio_free(pdata->vout_gpio);
 577
 578         if (pdata->hw_shutdown)
 579                 pdata->hw_shutdown(client);
 580
 581         if (pdata->hw_pwr)
 582                 pdata->hw_pwr(false);
 583
 584         return 0;
 585 }
 586
 587 #ifdef CONFIG_PM_SLEEP
 588 static int gp2a_suspend(struct device *dev)
 589 {
 590         struct i2c_client *client = to_i2c_client(dev);
 591         struct gp2a_data *dt = i2c_get_clientdata(client);
 592         int retval = 0;
 593         printk(KERN_ALERT"%s\n",__func__);
 594         if (device_may_wakeup(&client->dev)) {
 595                 enable_irq_wake(client->irq);
 596         } else {
 597                 mutex_lock(&dt->input->mutex);
 598                 if (dt->input->users)
 599                         retval = gp2a_disable(dt);
 600                 mutex_unlock(&dt->input->mutex);
 601         }
 602
 603         return retval;
 604 }
 605
 606 static int gp2a_resume(struct device *dev)
 607 {
 608         struct i2c_client *client = to_i2c_client(dev);
 609         struct gp2a_data *dt = i2c_get_clientdata(client);
 610         int retval = 0;
 611         printk(KERN_ALERT"%s\n",__func__);
 612         if (device_may_wakeup(&client->dev)) {
 613                 disable_irq_wake(client->irq);
 614         } else {
 615                 mutex_lock(&dt->input->mutex);
 616                 if (dt->input->users)
 617                         retval = gp2a_enable(dt);
 618                 mutex_unlock(&dt->input->mutex);
 619         }
 620
 621         return retval;
 622 }
 623 #endif
 624
 625 static SIMPLE_DEV_PM_OPS(gp2a_pm, gp2a_suspend, gp2a_resume);
 626
 627 static const struct i2c_device_id gp2a_i2c_id[] = {
 628         { GP2A_I2C_NAME, 0 },
 629         { }
 630 };
 631
 632 static struct i2c_driver gp2a_i2c_driver = {
 633         .driver = {
 634                 .name   = GP2A_I2C_NAME,
 635                 .owner  = THIS_MODULE,
 636                 .pm     = &gp2a_pm,
 637         },
 638         .probe          = gp2a_probe,
 639         .remove         = gp2a_remove,
 640         .id_table       = gp2a_i2c_id,
 641 };
 642
 643 module_i2c_driver(gp2a_i2c_driver);
 644
 645 MODULE_AUTHOR("Courtney Cavin <courtney.cavin@sonyericsson.com>");
 646 MODULE_DESCRIPTION("Sharp GP2AP002A00F I2C Proximity/Opto sensor driver");
 647 MODULE_LICENSE("GPL v2");