1 /* 2 * ST1232 Touchscreen Controller Driver 3 * 4 * Copyright (C) 2010 Renesas Solutions Corp. 5 * Tony SIM <chinyeow.sim.xt@renesas.com> 6 * 7 * Using code from: 8 * - android.git.kernel.org: projects/kernel/common.git: synaptics_i2c_rmi.c 9 * Copyright (C) 2007 Google, Inc. 10 * 11 * This software is licensed under the terms of the GNU General Public 12 * License version 2, as published by the Free Software Foundation, and 13 * may be copied, distributed, and modified under those terms. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 */ 20 21 #include <linux/delay.h> 22 #include <linux/gpio.h> 23 #include <linux/i2c.h> 24 #include <linux/input.h> 25 #include <linux/interrupt.h> 26 #include <linux/module.h> 27 #include <linux/of.h> 28 #include <linux/of_gpio.h> 29 #include <linux/pm_qos.h> 30 #include <linux/slab.h> 31 #include <linux/types.h> 32 33 #define ST1232_TS_NAME "st1232-ts" 34 35 #define MIN_X 0x00 36 #define MIN_Y 0x00 37 #define MAX_X 0x31f /* (800 - 1) */ 38 #define MAX_Y 0x1df /* (480 - 1) */ 39 #define MAX_AREA 0xff 40 #define MAX_FINGERS 2 41 42 struct st1232_ts_finger { 43 u16 x; 44 u16 y; 45 u8 t; 46 bool is_valid; 47 }; 48 49 struct st1232_ts_data { 50 struct i2c_client *client; 51 struct input_dev *input_dev; 52 struct st1232_ts_finger finger[MAX_FINGERS]; 53 struct dev_pm_qos_request low_latency_req; 54 int reset_gpio; 55 }; 56 57 static int st1232_ts_read_data(struct st1232_ts_data *ts) 58 { 59 struct st1232_ts_finger *finger = ts->finger; 60 struct i2c_client *client = ts->client; 61 struct i2c_msg msg[2]; 62 int error; 63 u8 start_reg; 64 u8 buf[10]; 65 66 /* read touchscreen data from ST1232 */ 67 msg[0].addr = client->addr; 68 msg[0].flags = 0; 69 msg[0].len = 1; 70 msg[0].buf = &start_reg; 71 start_reg = 0x10; 72 73 msg[1].addr = ts->client->addr; 74 msg[1].flags = I2C_M_RD; 75 msg[1].len = sizeof(buf); 76 msg[1].buf = buf; 77 78 error = i2c_transfer(client->adapter, msg, 2); 79 if (error < 0) 80 return error; 81 82 /* get "valid" bits */ 83 finger[0].is_valid = buf[2] >> 7; 84 finger[1].is_valid = buf[5] >> 7; 85 86 /* get xy coordinate */ 87 if (finger[0].is_valid) { 88 finger[0].x = ((buf[2] & 0x0070) << 4) | buf[3]; 89 finger[0].y = ((buf[2] & 0x0007) << 8) | buf[4]; 90 finger[0].t = buf[8]; 91 } 92 93 if (finger[1].is_valid) { 94 finger[1].x = ((buf[5] & 0x0070) << 4) | buf[6]; 95 finger[1].y = ((buf[5] & 0x0007) << 8) | buf[7]; 96 finger[1].t = buf[9]; 97 } 98 99 return 0; 100 } 101 102 static irqreturn_t st1232_ts_irq_handler(int irq, void *dev_id) 103 { 104 struct st1232_ts_data *ts = dev_id; 105 struct st1232_ts_finger *finger = ts->finger; 106 struct input_dev *input_dev = ts->input_dev; 107 int count = 0; 108 int i, ret; 109 110 ret = st1232_ts_read_data(ts); 111 if (ret < 0) 112 goto end; 113 114 /* multi touch protocol */ 115 for (i = 0; i < MAX_FINGERS; i++) { 116 if (!finger[i].is_valid) 117 continue; 118 119 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, finger[i].t); 120 input_report_abs(input_dev, ABS_MT_POSITION_X, finger[i].x); 121 input_report_abs(input_dev, ABS_MT_POSITION_Y, finger[i].y); 122 input_mt_sync(input_dev); 123 count++; 124 } 125 126 /* SYN_MT_REPORT only if no contact */ 127 if (!count) { 128 input_mt_sync(input_dev); 129 if (ts->low_latency_req.dev) { 130 dev_pm_qos_remove_request(&ts->low_latency_req); 131 ts->low_latency_req.dev = NULL; 132 } 133 } else if (!ts->low_latency_req.dev) { 134 /* First contact, request 100 us latency. */ 135 dev_pm_qos_add_ancestor_request(&ts->client->dev, 136 &ts->low_latency_req, 137 DEV_PM_QOS_RESUME_LATENCY, 100); 138 } 139 140 /* SYN_REPORT */ 141 input_sync(input_dev); 142 143 end: 144 return IRQ_HANDLED; 145 } 146 147 static void st1232_ts_power(struct st1232_ts_data *ts, bool poweron) 148 { 149 if (gpio_is_valid(ts->reset_gpio)) 150 gpio_direction_output(ts->reset_gpio, poweron); 151 } 152 153 static int st1232_ts_probe(struct i2c_client *client, 154 const struct i2c_device_id *id) 155 { 156 struct st1232_ts_data *ts; 157 struct input_dev *input_dev; 158 int error; 159 160 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 161 dev_err(&client->dev, "need I2C_FUNC_I2C\n"); 162 return -EIO; 163 } 164 165 if (!client->irq) { 166 dev_err(&client->dev, "no IRQ?\n"); 167 return -EINVAL; 168 } 169 170 ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL); 171 if (!ts) 172 return -ENOMEM; 173 174 input_dev = devm_input_allocate_device(&client->dev); 175 if (!input_dev) 176 return -ENOMEM; 177 178 ts->client = client; 179 ts->input_dev = input_dev; 180 181 ts->reset_gpio = of_get_gpio(client->dev.of_node, 0); 182 if (gpio_is_valid(ts->reset_gpio)) { 183 error = devm_gpio_request(&client->dev, ts->reset_gpio, NULL); 184 if (error) { 185 dev_err(&client->dev, 186 "Unable to request GPIO pin %d.\n", 187 ts->reset_gpio); 188 return error; 189 } 190 } 191 192 st1232_ts_power(ts, true); 193 194 input_dev->name = "st1232-touchscreen"; 195 input_dev->id.bustype = BUS_I2C; 196 input_dev->dev.parent = &client->dev; 197 198 __set_bit(EV_SYN, input_dev->evbit); 199 __set_bit(EV_KEY, input_dev->evbit); 200 __set_bit(EV_ABS, input_dev->evbit); 201 202 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0); 203 input_set_abs_params(input_dev, ABS_MT_POSITION_X, MIN_X, MAX_X, 0, 0); 204 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, MIN_Y, MAX_Y, 0, 0); 205 206 error = devm_request_threaded_irq(&client->dev, client->irq, 207 NULL, st1232_ts_irq_handler, 208 IRQF_ONESHOT, 209 client->name, ts); 210 if (error) { 211 dev_err(&client->dev, "Failed to register interrupt\n"); 212 return error; 213 } 214 215 error = input_register_device(ts->input_dev); 216 if (error) { 217 dev_err(&client->dev, "Unable to register %s input device\n", 218 input_dev->name); 219 return error; 220 } 221 222 i2c_set_clientdata(client, ts); 223 device_init_wakeup(&client->dev, 1); 224 225 return 0; 226 } 227 228 static int st1232_ts_remove(struct i2c_client *client) 229 { 230 struct st1232_ts_data *ts = i2c_get_clientdata(client); 231 232 st1232_ts_power(ts, false); 233 234 return 0; 235 } 236 237 static int __maybe_unused st1232_ts_suspend(struct device *dev) 238 { 239 struct i2c_client *client = to_i2c_client(dev); 240 struct st1232_ts_data *ts = i2c_get_clientdata(client); 241 242 if (device_may_wakeup(&client->dev)) { 243 enable_irq_wake(client->irq); 244 } else { 245 disable_irq(client->irq); 246 st1232_ts_power(ts, false); 247 } 248 249 return 0; 250 } 251 252 static int __maybe_unused st1232_ts_resume(struct device *dev) 253 { 254 struct i2c_client *client = to_i2c_client(dev); 255 struct st1232_ts_data *ts = i2c_get_clientdata(client); 256 257 if (device_may_wakeup(&client->dev)) { 258 disable_irq_wake(client->irq); 259 } else { 260 st1232_ts_power(ts, true); 261 enable_irq(client->irq); 262 } 263 264 return 0; 265 } 266 267 static SIMPLE_DEV_PM_OPS(st1232_ts_pm_ops, 268 st1232_ts_suspend, st1232_ts_resume); 269 270 static const struct i2c_device_id st1232_ts_id[] = { 271 { ST1232_TS_NAME, 0 }, 272 { } 273 }; 274 MODULE_DEVICE_TABLE(i2c, st1232_ts_id); 275 276 static const struct of_device_id st1232_ts_dt_ids[] = { 277 { .compatible = "sitronix,st1232", }, 278 { } 279 }; 280 MODULE_DEVICE_TABLE(of, st1232_ts_dt_ids); 281 282 static struct i2c_driver st1232_ts_driver = { 283 .probe = st1232_ts_probe, 284 .remove = st1232_ts_remove, 285 .id_table = st1232_ts_id, 286 .driver = { 287 .name = ST1232_TS_NAME, 288 .of_match_table = st1232_ts_dt_ids, 289 .pm = &st1232_ts_pm_ops, 290 }, 291 }; 292 293 module_i2c_driver(st1232_ts_driver); 294 295 MODULE_AUTHOR("Tony SIM <chinyeow.sim.xt@renesas.com>"); 296 MODULE_DESCRIPTION("SITRONIX ST1232 Touchscreen Controller Driver"); 297 MODULE_LICENSE("GPL"); 298