1 /* 2 * Driver for cypress touch screen controller 3 * 4 * Copyright (c) 2009 Aava Mobile 5 * 6 * Some cleanups by Alan Cox <alan@linux.intel.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include <linux/module.h> 23 #include <linux/kernel.h> 24 #include <linux/input.h> 25 #include <linux/slab.h> 26 #include <linux/interrupt.h> 27 #include <linux/io.h> 28 #include <linux/i2c.h> 29 #include <linux/gpio.h> 30 #include <linux/input/cy8ctmg110_pdata.h> 31 32 #define CY8CTMG110_DRIVER_NAME "cy8ctmg110" 33 34 /* Touch coordinates */ 35 #define CY8CTMG110_X_MIN 0 36 #define CY8CTMG110_Y_MIN 0 37 #define CY8CTMG110_X_MAX 759 38 #define CY8CTMG110_Y_MAX 465 39 40 41 /* cy8ctmg110 register definitions */ 42 #define CY8CTMG110_TOUCH_WAKEUP_TIME 0 43 #define CY8CTMG110_TOUCH_SLEEP_TIME 2 44 #define CY8CTMG110_TOUCH_X1 3 45 #define CY8CTMG110_TOUCH_Y1 5 46 #define CY8CTMG110_TOUCH_X2 7 47 #define CY8CTMG110_TOUCH_Y2 9 48 #define CY8CTMG110_FINGERS 11 49 #define CY8CTMG110_GESTURE 12 50 #define CY8CTMG110_REG_MAX 13 51 52 53 /* 54 * The touch driver structure. 55 */ 56 struct cy8ctmg110 { 57 struct input_dev *input; 58 char phys[32]; 59 struct i2c_client *client; 60 int reset_pin; 61 int irq_pin; 62 }; 63 64 /* 65 * cy8ctmg110_power is the routine that is called when touch hardware 66 * will powered off or on. 67 */ 68 static void cy8ctmg110_power(struct cy8ctmg110 *ts, bool poweron) 69 { 70 if (ts->reset_pin) 71 gpio_direction_output(ts->reset_pin, 1 - poweron); 72 } 73 74 static int cy8ctmg110_write_regs(struct cy8ctmg110 *tsc, unsigned char reg, 75 unsigned char len, unsigned char *value) 76 { 77 struct i2c_client *client = tsc->client; 78 int ret; 79 unsigned char i2c_data[6]; 80 81 BUG_ON(len > 5); 82 83 i2c_data[0] = reg; 84 memcpy(i2c_data + 1, value, len); 85 86 ret = i2c_master_send(client, i2c_data, len + 1); 87 if (ret != len + 1) { 88 dev_err(&client->dev, "i2c write data cmd failed\n"); 89 return ret < 0 ? ret : -EIO; 90 } 91 92 return 0; 93 } 94 95 static int cy8ctmg110_read_regs(struct cy8ctmg110 *tsc, 96 unsigned char *data, unsigned char len, unsigned char cmd) 97 { 98 struct i2c_client *client = tsc->client; 99 int ret; 100 struct i2c_msg msg[2] = { 101 /* first write slave position to i2c devices */ 102 { 103 .addr = client->addr, 104 .len = 1, 105 .buf = &cmd 106 }, 107 /* Second read data from position */ 108 { 109 .addr = client->addr, 110 .flags = I2C_M_RD, 111 .len = len, 112 .buf = data 113 } 114 }; 115 116 ret = i2c_transfer(client->adapter, msg, 2); 117 if (ret < 0) 118 return ret; 119 120 return 0; 121 } 122 123 static int cy8ctmg110_touch_pos(struct cy8ctmg110 *tsc) 124 { 125 struct input_dev *input = tsc->input; 126 unsigned char reg_p[CY8CTMG110_REG_MAX]; 127 int x, y; 128 129 memset(reg_p, 0, CY8CTMG110_REG_MAX); 130 131 /* Reading coordinates */ 132 if (cy8ctmg110_read_regs(tsc, reg_p, 9, CY8CTMG110_TOUCH_X1) != 0) 133 return -EIO; 134 135 y = reg_p[2] << 8 | reg_p[3]; 136 x = reg_p[0] << 8 | reg_p[1]; 137 138 /* Number of touch */ 139 if (reg_p[8] == 0) { 140 input_report_key(input, BTN_TOUCH, 0); 141 } else { 142 input_report_key(input, BTN_TOUCH, 1); 143 input_report_abs(input, ABS_X, x); 144 input_report_abs(input, ABS_Y, y); 145 } 146 147 input_sync(input); 148 149 return 0; 150 } 151 152 static int cy8ctmg110_set_sleepmode(struct cy8ctmg110 *ts, bool sleep) 153 { 154 unsigned char reg_p[3]; 155 156 if (sleep) { 157 reg_p[0] = 0x00; 158 reg_p[1] = 0xff; 159 reg_p[2] = 5; 160 } else { 161 reg_p[0] = 0x10; 162 reg_p[1] = 0xff; 163 reg_p[2] = 0; 164 } 165 166 return cy8ctmg110_write_regs(ts, CY8CTMG110_TOUCH_WAKEUP_TIME, 3, reg_p); 167 } 168 169 static irqreturn_t cy8ctmg110_irq_thread(int irq, void *dev_id) 170 { 171 struct cy8ctmg110 *tsc = dev_id; 172 173 cy8ctmg110_touch_pos(tsc); 174 175 return IRQ_HANDLED; 176 } 177 178 static int cy8ctmg110_probe(struct i2c_client *client, 179 const struct i2c_device_id *id) 180 { 181 const struct cy8ctmg110_pdata *pdata = dev_get_platdata(&client->dev); 182 struct cy8ctmg110 *ts; 183 struct input_dev *input_dev; 184 int err; 185 186 /* No pdata no way forward */ 187 if (pdata == NULL) { 188 dev_err(&client->dev, "no pdata\n"); 189 return -ENODEV; 190 } 191 192 if (!i2c_check_functionality(client->adapter, 193 I2C_FUNC_SMBUS_READ_WORD_DATA)) 194 return -EIO; 195 196 ts = kzalloc(sizeof(struct cy8ctmg110), GFP_KERNEL); 197 input_dev = input_allocate_device(); 198 if (!ts || !input_dev) { 199 err = -ENOMEM; 200 goto err_free_mem; 201 } 202 203 ts->client = client; 204 ts->input = input_dev; 205 ts->reset_pin = pdata->reset_pin; 206 ts->irq_pin = pdata->irq_pin; 207 208 snprintf(ts->phys, sizeof(ts->phys), 209 "%s/input0", dev_name(&client->dev)); 210 211 input_dev->name = CY8CTMG110_DRIVER_NAME " Touchscreen"; 212 input_dev->phys = ts->phys; 213 input_dev->id.bustype = BUS_I2C; 214 input_dev->dev.parent = &client->dev; 215 216 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 217 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 218 219 input_set_abs_params(input_dev, ABS_X, 220 CY8CTMG110_X_MIN, CY8CTMG110_X_MAX, 4, 0); 221 input_set_abs_params(input_dev, ABS_Y, 222 CY8CTMG110_Y_MIN, CY8CTMG110_Y_MAX, 4, 0); 223 224 if (ts->reset_pin) { 225 err = gpio_request(ts->reset_pin, NULL); 226 if (err) { 227 dev_err(&client->dev, 228 "Unable to request GPIO pin %d.\n", 229 ts->reset_pin); 230 goto err_free_mem; 231 } 232 } 233 234 cy8ctmg110_power(ts, true); 235 cy8ctmg110_set_sleepmode(ts, false); 236 237 err = gpio_request(ts->irq_pin, "touch_irq_key"); 238 if (err < 0) { 239 dev_err(&client->dev, 240 "Failed to request GPIO %d, error %d\n", 241 ts->irq_pin, err); 242 goto err_shutoff_device; 243 } 244 245 err = gpio_direction_input(ts->irq_pin); 246 if (err < 0) { 247 dev_err(&client->dev, 248 "Failed to configure input direction for GPIO %d, error %d\n", 249 ts->irq_pin, err); 250 goto err_free_irq_gpio; 251 } 252 253 client->irq = gpio_to_irq(ts->irq_pin); 254 if (client->irq < 0) { 255 err = client->irq; 256 dev_err(&client->dev, 257 "Unable to get irq number for GPIO %d, error %d\n", 258 ts->irq_pin, err); 259 goto err_free_irq_gpio; 260 } 261 262 err = request_threaded_irq(client->irq, NULL, cy8ctmg110_irq_thread, 263 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 264 "touch_reset_key", ts); 265 if (err < 0) { 266 dev_err(&client->dev, 267 "irq %d busy? error %d\n", client->irq, err); 268 goto err_free_irq_gpio; 269 } 270 271 err = input_register_device(input_dev); 272 if (err) 273 goto err_free_irq; 274 275 i2c_set_clientdata(client, ts); 276 device_init_wakeup(&client->dev, 1); 277 return 0; 278 279 err_free_irq: 280 free_irq(client->irq, ts); 281 err_free_irq_gpio: 282 gpio_free(ts->irq_pin); 283 err_shutoff_device: 284 cy8ctmg110_set_sleepmode(ts, true); 285 cy8ctmg110_power(ts, false); 286 if (ts->reset_pin) 287 gpio_free(ts->reset_pin); 288 err_free_mem: 289 input_free_device(input_dev); 290 kfree(ts); 291 return err; 292 } 293 294 static int __maybe_unused cy8ctmg110_suspend(struct device *dev) 295 { 296 struct i2c_client *client = to_i2c_client(dev); 297 struct cy8ctmg110 *ts = i2c_get_clientdata(client); 298 299 if (device_may_wakeup(&client->dev)) 300 enable_irq_wake(client->irq); 301 else { 302 cy8ctmg110_set_sleepmode(ts, true); 303 cy8ctmg110_power(ts, false); 304 } 305 return 0; 306 } 307 308 static int __maybe_unused cy8ctmg110_resume(struct device *dev) 309 { 310 struct i2c_client *client = to_i2c_client(dev); 311 struct cy8ctmg110 *ts = i2c_get_clientdata(client); 312 313 if (device_may_wakeup(&client->dev)) 314 disable_irq_wake(client->irq); 315 else { 316 cy8ctmg110_power(ts, true); 317 cy8ctmg110_set_sleepmode(ts, false); 318 } 319 return 0; 320 } 321 322 static SIMPLE_DEV_PM_OPS(cy8ctmg110_pm, cy8ctmg110_suspend, cy8ctmg110_resume); 323 324 static int cy8ctmg110_remove(struct i2c_client *client) 325 { 326 struct cy8ctmg110 *ts = i2c_get_clientdata(client); 327 328 cy8ctmg110_set_sleepmode(ts, true); 329 cy8ctmg110_power(ts, false); 330 331 free_irq(client->irq, ts); 332 input_unregister_device(ts->input); 333 gpio_free(ts->irq_pin); 334 if (ts->reset_pin) 335 gpio_free(ts->reset_pin); 336 kfree(ts); 337 338 return 0; 339 } 340 341 static const struct i2c_device_id cy8ctmg110_idtable[] = { 342 { CY8CTMG110_DRIVER_NAME, 1 }, 343 { } 344 }; 345 346 MODULE_DEVICE_TABLE(i2c, cy8ctmg110_idtable); 347 348 static struct i2c_driver cy8ctmg110_driver = { 349 .driver = { 350 .owner = THIS_MODULE, 351 .name = CY8CTMG110_DRIVER_NAME, 352 .pm = &cy8ctmg110_pm, 353 }, 354 .id_table = cy8ctmg110_idtable, 355 .probe = cy8ctmg110_probe, 356 .remove = cy8ctmg110_remove, 357 }; 358 359 module_i2c_driver(cy8ctmg110_driver); 360 361 MODULE_AUTHOR("Samuli Konttila <samuli.konttila@aavamobile.com>"); 362 MODULE_DESCRIPTION("cy8ctmg110 TouchScreen Driver"); 363 MODULE_LICENSE("GPL v2"); 364