drivers/input/sensors/lsensor/ls_al3006.c

   1 /* drivers/input/sensors/access/kxtik.c\r
   2  *\r
   3  * Copyright (C) 2012-2015 ROCKCHIP.\r
   4  * Author: luowei <lw@rock-chips.com>\r
   5  *\r
   6  * This software is licensed under the terms of the GNU General Public\r
   7  * License version 2, as published by the Free Software Foundation, and\r
   8  * may be copied, distributed, and modified under those terms.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful,\r
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13  * GNU General Public License for more details.\r
  14  *\r
  15  */\r
  16 #include <linux/interrupt.h>\r
  17 #include <linux/i2c.h>\r
  18 #include <linux/slab.h>\r
  19 #include <linux/irq.h>\r
  20 #include <linux/miscdevice.h>\r
  21 #include <linux/gpio.h>\r
  22 #include <asm/uaccess.h>\r
  23 #include <asm/atomic.h>\r
  24 #include <linux/delay.h>\r
  25 #include <linux/input.h>\r
  26 #include <linux/workqueue.h>\r
  27 #include <linux/freezer.h>\r
  28 #include <mach/gpio.h>\r
  29 #include <mach/board.h> \r
  30 #ifdef CONFIG_HAS_EARLYSUSPEND\r
  31 #include <linux/earlysuspend.h>\r
  32 #endif\r
  33 #include <linux/sensor-dev.h>\r
  34 \r
  35 \r
  36 #define CONFIG_REG        (0x00)\r
  37 #define TIM_CTL_REG       (0x01)\r
  38 #define ALS_CTL_REG       (0x02)\r
  39 #define INT_STATUS_REG    (0x03)\r
  40 #define PS_CTL_REG        (0x04)\r
  41 #define PS_ALS_DATA_REG   (0x05)\r
  42 #define ALS_WINDOWS_REG   (0x08)\r
  43 \r
  44 //enable bit[ 0-1], in register CONFIG_REG\r
  45 #define ONLY_ALS_EN       (0x00)\r
  46 #define ONLY_PROX_EN      (0x01)\r
  47 #define ALL_PROX_ALS_EN   (0x02)\r
  48 #define ALL_IDLE          (0x03)\r
  49 \r
  50 #define POWER_MODE_MASK   (0x0C)\r
  51 #define POWER_UP_MODE     (0x00)\r
  52 #define POWER_DOWN_MODE   (0x08)\r
  53 #define POWER_RESET_MODE  (0x0C)\r
  54 \r
  55 static int sensor_power_updown(struct i2c_client *client, int on)\r
  56 {\r
  57         int result = 0;\r
  58         char value = 0;\r
  59         int i = 0;\r
  60         for(i=0; i<3; i++)\r
  61         {\r
  62                 if(!on)\r
  63                 {\r
  64                         value = sensor_read_reg(client, CONFIG_REG);\r
  65                         value &= ~POWER_MODE_MASK;\r
  66                         value |= POWER_DOWN_MODE;\r
  67                         result = sensor_write_reg(client, CONFIG_REG, value);\r
  68                         if(result)\r
  69                                 return result;\r
  70                 }\r
  71                 else\r
  72                 {\r
  73                         value = sensor_read_reg(client, CONFIG_REG);\r
  74                         value &= ~POWER_MODE_MASK;\r
  75                         value |= POWER_UP_MODE;\r
  76                         result = sensor_write_reg(client, CONFIG_REG, value);\r
  77                         if(result)\r
  78                                 return result;\r
  79                 }\r
  80                 \r
  81                 if(!result)\r
  82                 break;\r
  83         }\r
  84 \r
  85         if(i>1)\r
  86         printk("%s:set %d times",__func__,i);\r
  87         \r
  88         return result;\r
  89 }\r
  90 \r
  91 /****************operate according to sensor chip:start************/\r
  92 \r
  93 static int sensor_active(struct i2c_client *client, int enable, int rate)\r
  94 {\r
  95         struct sensor_private_data *sensor =\r
  96             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
  97         int result = 0;\r
  98         char value = 0;\r
  99 \r
 100         if(enable)      \r
 101         sensor_power_updown(client, 1);\r
 102 \r
 103         value = sensor_read_reg(client, sensor->ops->ctrl_reg);\r
 104         \r
 105         //register setting according to chip datasheet          \r
 106         if(enable)\r
 107         {       \r
 108                 if( (value & 0x03) == ONLY_PROX_EN )\r
 109                 {\r
 110                         value &= ~0x03;\r
 111                         value |= ALL_PROX_ALS_EN;\r
 112                 }\r
 113                 else if((value & 0x03) == ALL_IDLE )\r
 114                 {\r
 115                         value &= ~0x03;\r
 116                         value |= ONLY_ALS_EN;\r
 117                 }\r
 118 \r
 119         }\r
 120         else\r
 121         {\r
 122                 if( (value & 0x03) == ONLY_ALS_EN )\r
 123                 {\r
 124                         value &= ~0x03;\r
 125                         value |= ALL_IDLE;\r
 126                 }\r
 127                 else if((value & 0x03) == ALL_PROX_ALS_EN )\r
 128                 {\r
 129                         value &= ~0x03;\r
 130                         value |= ONLY_PROX_EN;\r
 131                 }\r
 132         \r
 133         }\r
 134         \r
 135         sensor->ops->ctrl_data = value;\r
 136         \r
 137         DBG("%s:reg=0x%x,reg_ctrl=0x%x,enable=%d\n",__func__,sensor->ops->ctrl_reg, sensor->ops->ctrl_data, enable);\r
 138         result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);\r
 139         if(result)\r
 140                 printk("%s:fail to active sensor\n",__func__);\r
 141 \r
 142         return result;\r
 143 \r
 144 }\r
 145 \r
 146 \r
 147 static int sensor_init(struct i2c_client *client)\r
 148 {       \r
 149         struct sensor_private_data *sensor =\r
 150             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 151         int result = 0;\r
 152         char value = 0;\r
 153         \r
 154         sensor_power_updown(client, 0);\r
 155         \r
 156         result = sensor->ops->active(client,0,0);\r
 157         if(result)\r
 158         {\r
 159                 printk("%s:line=%d,error\n",__func__,__LINE__);\r
 160                 return result;\r
 161         }\r
 162         \r
 163         sensor->status_cur = SENSOR_OFF;\r
 164 \r
 165         value = 0x41;//The ADC effective resolution = 9;  Low lux threshold level = 1;\r
 166         //value = 0x69; //The ADC effective resolution = 17;  Low lux threshold level = 9;
 167         result = sensor_write_reg(client, ALS_CTL_REG, value);\r
 168         if(result)\r
 169         {\r
 170                 printk("%s:line=%d,error\n",__func__,__LINE__);\r
 171                 return result;\r
 172         }\r
 173
 174         //value = 0x04;//0x01-0x0f; 17%->93.5% if value = 0x04,then Compensate Loss 52%
 175         value = 0x02;//0x01-0x0f; 17%->93.5% if value = 0x02,then Compensate Loss 31%   \r
 176         result = sensor_write_reg(client, ALS_WINDOWS_REG, value);\r
 177         if(result)\r
 178         {\r
 179                 printk("%s:line=%d,error\n",__func__,__LINE__);\r
 180                 return result;\r
 181         }\r
 182                 \r
 183         return result;\r
 184 }\r
 185 \r
 186 \r
 187 static int light_report_value(struct input_dev *input, int data)\r
 188 {\r
 189         unsigned char index = 0;\r
 190         if(data <= 0){\r
 191                 index = 0;goto report;\r
 192         }\r
 193         else if(data <= 2){\r
 194                 index = 1;goto report;\r
 195         }\r
 196         else if(data <= 4){\r
 197                 index = 2;goto report;\r
 198         }\r
 199         else if(data <= 8){\r
 200                 index = 3;goto report;\r
 201         }\r
 202         else if(data <= 14){\r
 203                 index = 4;goto report;\r
 204         }\r
 205         else if(data <= 20){\r
 206                 index = 5;goto report;\r
 207         }\r
 208         else if(data <= 26){\r
 209                 index = 6;goto report;\r
 210         }\r
 211         else{\r
 212                 index = 7;goto report;\r
 213         }\r
 214 \r
 215 report:\r
 216         input_report_abs(input, ABS_MISC, index);\r
 217         input_sync(input);\r
 218 \r
 219         return index;\r
 220 }\r
 221 \r
 222 \r
 223 static int sensor_report_value(struct i2c_client *client)\r
 224 {\r
 225         struct sensor_private_data *sensor =\r
 226             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 227         int result = 0;\r
 228         char value = 0;\r
 229         char index = 0;\r
 230         \r
 231         if(sensor->pdata->irq_enable)\r
 232         {\r
 233                 if(sensor->ops->int_status_reg)\r
 234                 {\r
 235                         value = sensor_read_reg(client, sensor->ops->int_status_reg);\r
 236                 }\r
 237                 \r
 238         }\r
 239 \r
 240         value = sensor_read_reg(client, sensor->ops->read_reg);\r
 241         index = light_report_value(sensor->input_dev, value&0x3f); // bit0-5  is ls data;\r
 242         \r
 243         DBG("%s:%s result=0x%x,index=%d\n",__func__,sensor->ops->name, value,index);\r
 244         \r
 245         return result;\r
 246 }\r
 247 \r
 248 struct sensor_operate light_al3006_ops = {\r
 249         .name                           = "ls_al3006",\r
 250         .type                           = SENSOR_TYPE_LIGHT,    //sensor type and it should be correct\r
 251         .id_i2c                         = LIGHT_ID_AL3006,      //i2c id number\r
 252         .read_reg                       = PS_ALS_DATA_REG,      //read data\r
 253         .read_len                       = 1,                    //data length\r
 254         .id_reg                         = SENSOR_UNKNOW_DATA,   //read device id from this register\r
 255         .id_data                        = SENSOR_UNKNOW_DATA,   //device id\r
 256         .precision                      = 8,                    //8 bits\r
 257         .ctrl_reg                       = CONFIG_REG,           //enable or disable \r
 258         .int_status_reg                 = INT_STATUS_REG,       //intterupt status register\r
 259         .range                          = {100,65535},          //range\r
 260         .brightness                                        ={10,255},                          // brightness\r
 261         .trig                           = IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_SHARED,                \r
 262         .active                         = sensor_active,        \r
 263         .init                           = sensor_init,\r
 264         .report                         = sensor_report_value,\r
 265 };\r
 266 \r
 267 /****************operate according to sensor chip:end************/\r
 268 \r
 269 //function name should not be changed\r
 270 static struct sensor_operate *light_get_ops(void)\r
 271 {\r
 272         return &light_al3006_ops;\r
 273 }\r
 274 \r
 275 \r
 276 static int __init light_al3006_init(void)\r
 277 {\r
 278         struct sensor_operate *ops = light_get_ops();\r
 279         int result = 0;\r
 280         int type = ops->type;\r
 281         result = sensor_register_slave(type, NULL, NULL, light_get_ops);\r
 282         return result;\r
 283 }\r
 284 \r
 285 static void __exit light_al3006_exit(void)\r
 286 {\r
 287         struct sensor_operate *ops = light_get_ops();\r
 288         int type = ops->type;\r
 289         sensor_unregister_slave(type, NULL, NULL, light_get_ops);\r
 290 }\r
 291 \r
 292 \r
 293 module_init(light_al3006_init);\r
 294 module_exit(light_al3006_exit);\r
 295 \r
 296 \r