drivers/input/sensors/sensor-i2c.c

   1 /* drivers/input/sensors/sensor-i2c.c - sensor i2c handle\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 #define SENSOR_I2C_RATE 200*1000\r
  36 \r
  37 #if 0\r
  38 #define SENSOR_DEBUG_TYPE SENSOR_TYPE_COMPASS\r
  39 #define DBG(x...) if(sensor->pdata->type == SENSOR_DEBUG_TYPE) printk(x)\r
  40 #else\r
  41 #define DBG(x...)\r
  42 #endif\r
  43 \r
  44 static int sensor_i2c_write(struct i2c_adapter *i2c_adap,\r
  45                             unsigned char address,\r
  46                             unsigned int len, unsigned char const *data)\r
  47 {\r
  48         struct i2c_msg msgs[1];\r
  49         int res;\r
  50 \r
  51         if (!data || !i2c_adap) {\r
  52                 printk("%s:line=%d,error\n",__func__,__LINE__);\r
  53                 return -EINVAL;\r
  54         }\r
  55 \r
  56         msgs[0].addr = address;\r
  57         msgs[0].flags = 0;      /* write */\r
  58         msgs[0].buf = (unsigned char *)data;\r
  59         msgs[0].len = len;\r
  60         msgs[0].scl_rate = SENSOR_I2C_RATE;\r
  61 \r
  62         res = i2c_transfer(i2c_adap, msgs, 1);\r
  63         if (res == 1)\r
  64                 return 0;\r
  65         else if(res == 0)\r
  66                 return -EBUSY;\r
  67         else\r
  68                 return res;\r
  69 \r
  70 }\r
  71 \r
  72 static int senosr_i2c_read(struct i2c_adapter *i2c_adap,\r
  73                            unsigned char address, unsigned char reg,\r
  74                            unsigned int len, unsigned char *data)\r
  75 {\r
  76         struct i2c_msg msgs[2];\r
  77         int res;\r
  78 \r
  79         if (!data || !i2c_adap) {\r
  80                 printk("%s:line=%d,error\n",__func__,__LINE__);\r
  81                 return -EINVAL;\r
  82         }\r
  83 \r
  84         msgs[0].addr = address;\r
  85         msgs[0].flags = 0;      /* write */\r
  86         msgs[0].buf = &reg;\r
  87         msgs[0].len = 1;\r
  88         msgs[0].scl_rate = SENSOR_I2C_RATE;\r
  89         \r
  90         msgs[1].addr = address;\r
  91         msgs[1].flags = I2C_M_RD;\r
  92         msgs[1].buf = data;\r
  93         msgs[1].len = len;\r
  94         msgs[1].scl_rate = SENSOR_I2C_RATE;     \r
  95 \r
  96         res = i2c_transfer(i2c_adap, msgs, 2);\r
  97         if (res == 2)\r
  98                 return 0;\r
  99         else if(res == 0)\r
 100                 return -EBUSY;\r
 101         else\r
 102                 return res;\r
 103 \r
 104 }\r
 105 \r
 106 \r
 107 int sensor_rx_data(struct i2c_client *client, char *rxData, int length)\r
 108 {\r
 109 #ifdef SENSOR_DEBUG_TYPE\r
 110         struct sensor_private_data* sensor = \r
 111                 (struct sensor_private_data *)i2c_get_clientdata(client);\r
 112         int i = 0;\r
 113 #endif\r
 114         int ret = 0;\r
 115         char reg = rxData[0];\r
 116         ret = senosr_i2c_read(client->adapter, client->addr, reg, length, rxData);\r
 117         \r
 118 #ifdef SENSOR_DEBUG_TYPE\r
 119         DBG("addr=0x%x,len=%d,rxdata:",reg,length);\r
 120         for(i=0; i<length; i++)\r
 121                 DBG("0x%x,",rxData[i]);\r
 122         DBG("\n");\r
 123 #endif  \r
 124         return ret;\r
 125 }\r
 126 EXPORT_SYMBOL(sensor_rx_data);\r
 127 \r
 128 int sensor_tx_data(struct i2c_client *client, char *txData, int length)\r
 129 {\r
 130 #ifdef SENSOR_DEBUG_TYPE        \r
 131         struct sensor_private_data* sensor = \r
 132                 (struct sensor_private_data *)i2c_get_clientdata(client);\r
 133         int i = 0;\r
 134 #endif\r
 135         int ret = 0;\r
 136 #ifdef SENSOR_DEBUG_TYPE        \r
 137         DBG("addr=0x%x,len=%d,txdata:",txData[0],length);\r
 138         for(i=1; i<length; i++)\r
 139                 DBG("0x%x,",txData[i]);\r
 140         DBG("\n");\r
 141 #endif\r
 142         ret = sensor_i2c_write(client->adapter, client->addr, length, txData);\r
 143         return ret;\r
 144 \r
 145 }\r
 146 EXPORT_SYMBOL(sensor_tx_data);\r
 147 \r
 148 int sensor_write_reg(struct i2c_client *client, int addr, int value)\r
 149 {\r
 150         char buffer[2];\r
 151         int ret = 0;\r
 152         struct sensor_private_data* sensor = \r
 153                 (struct sensor_private_data *)i2c_get_clientdata(client);\r
 154         \r
 155         mutex_lock(&sensor->i2c_mutex); \r
 156         buffer[0] = addr;\r
 157         buffer[1] = value;\r
 158         ret = sensor_tx_data(client, &buffer[0], 2);    \r
 159         mutex_unlock(&sensor->i2c_mutex);       \r
 160         return ret;\r
 161 }\r
 162 EXPORT_SYMBOL(sensor_write_reg);\r
 163 \r
 164 int sensor_read_reg(struct i2c_client *client, int addr)\r
 165 {\r
 166         char tmp[1] = {0};\r
 167         int ret = 0;    \r
 168         struct sensor_private_data* sensor = \r
 169                 (struct sensor_private_data *)i2c_get_clientdata(client);\r
 170         \r
 171         mutex_lock(&sensor->i2c_mutex); \r
 172         tmp[0] = addr;\r
 173         ret = sensor_rx_data(client, tmp, 1);\r
 174         mutex_unlock(&sensor->i2c_mutex);\r
 175         \r
 176         return tmp[0];\r
 177 }\r
 178 \r
 179 EXPORT_SYMBOL(sensor_read_reg);\r
 180 \r
 181 \r
 182 int sensor_tx_data_normal(struct i2c_client *client, char *buf, int num)\r
 183 {\r
 184         int ret = 0;\r
 185         ret = i2c_master_normal_send(client, buf, num, SENSOR_I2C_RATE);\r
 186         \r
 187         return (ret == num) ? 0 : ret;\r
 188 }\r
 189 EXPORT_SYMBOL(sensor_tx_data_normal);\r
 190 \r
 191 \r
 192 int sensor_rx_data_normal(struct i2c_client *client, char *buf, int num)\r
 193 {\r
 194         int ret = 0;\r
 195         ret = i2c_master_normal_recv(client, buf, num, SENSOR_I2C_RATE);\r
 196         \r
 197         return (ret == num) ? 0 : ret;\r
 198 }\r
 199 \r
 200 EXPORT_SYMBOL(sensor_rx_data_normal);\r
 201 \r
 202 \r
 203 int sensor_write_reg_normal(struct i2c_client *client, char value)\r
 204 {\r
 205         char buffer[2];\r
 206         int ret = 0;\r
 207         struct sensor_private_data* sensor = \r
 208                 (struct sensor_private_data *)i2c_get_clientdata(client);\r
 209         \r
 210         mutex_lock(&sensor->i2c_mutex); \r
 211         buffer[0] = value;\r
 212         ret = sensor_tx_data_normal(client, &buffer[0], 1);     \r
 213         mutex_unlock(&sensor->i2c_mutex);       \r
 214         return ret;\r
 215 }\r
 216 EXPORT_SYMBOL(sensor_write_reg_normal);\r
 217 \r
 218 int sensor_read_reg_normal(struct i2c_client *client)\r
 219 {\r
 220         char tmp[1] = {0};\r
 221         int ret = 0;    \r
 222         struct sensor_private_data* sensor = \r
 223                 (struct sensor_private_data *)i2c_get_clientdata(client);\r
 224         \r
 225         mutex_lock(&sensor->i2c_mutex); \r
 226         ret = sensor_rx_data_normal(client, tmp, 1);\r
 227         mutex_unlock(&sensor->i2c_mutex);\r
 228         \r
 229         return tmp[0];\r
 230 }\r
 231 \r
 232 EXPORT_SYMBOL(sensor_read_reg_normal);\r
 233 \r