2 * Copyright (C) 2012 Samsung Electronics Co.Ltd
3 * Author: Joonyoung Shim <jy0922.shim@samsung.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/delay.h>
14 #include <linux/i2c.h>
15 #include <linux/i2c/mms114.h>
16 #include <linux/input/mt.h>
17 #include <linux/interrupt.h>
18 #include <linux/regulator/consumer.h>
19 #include <linux/slab.h>
21 /* Write only registers */
22 #define MMS114_MODE_CONTROL 0x01
23 #define MMS114_OPERATION_MODE_MASK 0xE
24 #define MMS114_ACTIVE (1 << 1)
26 #define MMS114_XY_RESOLUTION_H 0x02
27 #define MMS114_X_RESOLUTION 0x03
28 #define MMS114_Y_RESOLUTION 0x04
29 #define MMS114_CONTACT_THRESHOLD 0x05
30 #define MMS114_MOVING_THRESHOLD 0x06
32 /* Read only registers */
33 #define MMS114_PACKET_SIZE 0x0F
34 #define MMS114_INFOMATION 0x10
35 #define MMS114_TSP_REV 0xF0
37 /* Minimum delay time is 50us between stop and start signal of i2c */
38 #define MMS114_I2C_DELAY 50
40 /* 200ms needs after power on */
41 #define MMS114_POWERON_DELAY 200
43 /* Touchscreen absolute values */
44 #define MMS114_MAX_AREA 0xff
46 #define MMS114_MAX_TOUCH 10
47 #define MMS114_PACKET_NUM 8
50 #define MMS114_TYPE_NONE 0
51 #define MMS114_TYPE_TOUCHSCREEN 1
52 #define MMS114_TYPE_TOUCHKEY 2
55 struct i2c_client
*client
;
56 struct input_dev
*input_dev
;
57 struct regulator
*core_reg
;
58 struct regulator
*io_reg
;
59 const struct mms114_platform_data
*pdata
;
61 /* Use cache data for mode control register(write only) */
62 u8 cache_mode_control
;
66 u8 id
:4, reserved_bit4
:1, type
:2, pressed
:1;
75 static int __mms114_read_reg(struct mms114_data
*data
, unsigned int reg
,
76 unsigned int len
, u8
*val
)
78 struct i2c_client
*client
= data
->client
;
79 struct i2c_msg xfer
[2];
83 if (reg
<= MMS114_MODE_CONTROL
&& reg
+ len
> MMS114_MODE_CONTROL
)
86 /* Write register: use repeated start */
87 xfer
[0].addr
= client
->addr
;
88 xfer
[0].flags
= I2C_M_TEN
| I2C_M_NOSTART
;
93 xfer
[1].addr
= client
->addr
;
94 xfer
[1].flags
= I2C_M_RD
;
98 error
= i2c_transfer(client
->adapter
, xfer
, 2);
100 dev_err(&client
->dev
,
101 "%s: i2c transfer failed (%d)\n", __func__
, error
);
102 return error
< 0 ? error
: -EIO
;
104 udelay(MMS114_I2C_DELAY
);
109 static int mms114_read_reg(struct mms114_data
*data
, unsigned int reg
)
114 if (reg
== MMS114_MODE_CONTROL
)
115 return data
->cache_mode_control
;
117 error
= __mms114_read_reg(data
, reg
, 1, &val
);
118 return error
< 0 ? error
: val
;
121 static int mms114_write_reg(struct mms114_data
*data
, unsigned int reg
,
124 struct i2c_client
*client
= data
->client
;
131 error
= i2c_master_send(client
, buf
, 2);
133 dev_err(&client
->dev
,
134 "%s: i2c send failed (%d)\n", __func__
, error
);
135 return error
< 0 ? error
: -EIO
;
137 udelay(MMS114_I2C_DELAY
);
139 if (reg
== MMS114_MODE_CONTROL
)
140 data
->cache_mode_control
= val
;
145 static void mms114_process_mt(struct mms114_data
*data
, struct mms114_touch
*touch
)
147 const struct mms114_platform_data
*pdata
= data
->pdata
;
148 struct i2c_client
*client
= data
->client
;
149 struct input_dev
*input_dev
= data
->input_dev
;
154 if (touch
->id
> MMS114_MAX_TOUCH
) {
155 dev_err(&client
->dev
, "Wrong touch id (%d)\n", touch
->id
);
159 if (touch
->type
!= MMS114_TYPE_TOUCHSCREEN
) {
160 dev_err(&client
->dev
, "Wrong touch type (%d)\n", touch
->type
);
165 x
= touch
->x_lo
| touch
->x_hi
<< 8;
166 y
= touch
->y_lo
| touch
->y_hi
<< 8;
167 if (x
> pdata
->x_size
|| y
> pdata
->y_size
) {
168 dev_dbg(&client
->dev
,
169 "Wrong touch coordinates (%d, %d)\n", x
, y
);
174 x
= pdata
->x_size
- x
;
176 y
= pdata
->y_size
- y
;
178 dev_dbg(&client
->dev
,
179 "id: %d, type: %d, pressed: %d, x: %d, y: %d, width: %d, strength: %d\n",
180 id
, touch
->type
, touch
->pressed
,
181 x
, y
, touch
->width
, touch
->strength
);
183 input_mt_slot(input_dev
, id
);
184 input_mt_report_slot_state(input_dev
, MT_TOOL_FINGER
, touch
->pressed
);
186 if (touch
->pressed
) {
187 input_report_abs(input_dev
, ABS_MT_TOUCH_MAJOR
, touch
->width
);
188 input_report_abs(input_dev
, ABS_MT_POSITION_X
, x
);
189 input_report_abs(input_dev
, ABS_MT_POSITION_Y
, y
);
190 input_report_abs(input_dev
, ABS_MT_PRESSURE
, touch
->strength
);
194 static irqreturn_t
mms114_interrupt(int irq
, void *dev_id
)
196 struct mms114_data
*data
= dev_id
;
197 struct input_dev
*input_dev
= data
->input_dev
;
198 struct mms114_touch touch
[MMS114_MAX_TOUCH
];
204 mutex_lock(&input_dev
->mutex
);
205 if (!input_dev
->users
) {
206 mutex_unlock(&input_dev
->mutex
);
209 mutex_unlock(&input_dev
->mutex
);
211 packet_size
= mms114_read_reg(data
, MMS114_PACKET_SIZE
);
212 if (packet_size
<= 0)
215 touch_size
= packet_size
/ MMS114_PACKET_NUM
;
217 error
= __mms114_read_reg(data
, MMS114_INFOMATION
, packet_size
,
222 for (index
= 0; index
< touch_size
; index
++)
223 mms114_process_mt(data
, touch
+ index
);
225 input_mt_report_pointer_emulation(data
->input_dev
, true);
226 input_sync(data
->input_dev
);
232 static int mms114_set_active(struct mms114_data
*data
, bool active
)
236 val
= mms114_read_reg(data
, MMS114_MODE_CONTROL
);
240 val
&= ~MMS114_OPERATION_MODE_MASK
;
242 /* If active is false, sleep mode */
244 val
|= MMS114_ACTIVE
;
246 return mms114_write_reg(data
, MMS114_MODE_CONTROL
, val
);
249 static int mms114_get_version(struct mms114_data
*data
)
251 struct device
*dev
= &data
->client
->dev
;
255 error
= __mms114_read_reg(data
, MMS114_TSP_REV
, 6, buf
);
259 dev_info(dev
, "TSP Rev: 0x%x, HW Rev: 0x%x, Firmware Ver: 0x%x\n",
260 buf
[0], buf
[1], buf
[3]);
265 static int mms114_setup_regs(struct mms114_data
*data
)
267 const struct mms114_platform_data
*pdata
= data
->pdata
;
271 error
= mms114_get_version(data
);
275 error
= mms114_set_active(data
, true);
279 val
= (pdata
->x_size
>> 8) & 0xf;
280 val
|= ((pdata
->y_size
>> 8) & 0xf) << 4;
281 error
= mms114_write_reg(data
, MMS114_XY_RESOLUTION_H
, val
);
285 val
= pdata
->x_size
& 0xff;
286 error
= mms114_write_reg(data
, MMS114_X_RESOLUTION
, val
);
290 val
= pdata
->y_size
& 0xff;
291 error
= mms114_write_reg(data
, MMS114_Y_RESOLUTION
, val
);
295 if (pdata
->contact_threshold
) {
296 error
= mms114_write_reg(data
, MMS114_CONTACT_THRESHOLD
,
297 pdata
->contact_threshold
);
302 if (pdata
->moving_threshold
) {
303 error
= mms114_write_reg(data
, MMS114_MOVING_THRESHOLD
,
304 pdata
->moving_threshold
);
312 static int mms114_start(struct mms114_data
*data
)
314 struct i2c_client
*client
= data
->client
;
318 regulator_enable(data
->core_reg
);
320 regulator_enable(data
->io_reg
);
321 mdelay(MMS114_POWERON_DELAY
);
323 error
= mms114_setup_regs(data
);
327 if (data
->pdata
->cfg_pin
)
328 data
->pdata
->cfg_pin(true);
330 enable_irq(client
->irq
);
335 static void mms114_stop(struct mms114_data
*data
)
337 struct i2c_client
*client
= data
->client
;
339 disable_irq(client
->irq
);
341 if (data
->pdata
->cfg_pin
)
342 data
->pdata
->cfg_pin(false);
345 regulator_disable(data
->io_reg
);
347 regulator_disable(data
->core_reg
);
350 static int mms114_input_open(struct input_dev
*dev
)
352 struct mms114_data
*data
= input_get_drvdata(dev
);
354 return mms114_start(data
);
357 static void mms114_input_close(struct input_dev
*dev
)
359 struct mms114_data
*data
= input_get_drvdata(dev
);
365 static struct mms114_platform_data
*mms114_parse_dt(struct device
*dev
)
367 struct mms114_platform_data
*pdata
;
368 struct device_node
*np
= dev
->of_node
;
373 pdata
= devm_kzalloc(dev
, sizeof(*pdata
), GFP_KERNEL
);
375 dev_err(dev
, "failed to allocate platform data\n");
379 if (of_property_read_u32(np
, "x-size", &pdata
->x_size
)) {
380 dev_err(dev
, "failed to get x-size property\n");
384 if (of_property_read_u32(np
, "y-size", &pdata
->y_size
)) {
385 dev_err(dev
, "failed to get y-size property\n");
389 of_property_read_u32(np
, "contact-threshold",
390 &pdata
->contact_threshold
);
391 of_property_read_u32(np
, "moving-threshold",
392 &pdata
->moving_threshold
);
394 if (of_find_property(np
, "x-invert", NULL
))
395 pdata
->x_invert
= true;
396 if (of_find_property(np
, "y-invert", NULL
))
397 pdata
->y_invert
= true;
402 static inline struct mms114_platform_data
*mms114_parse_dt(struct device
*dev
)
408 static int mms114_probe(struct i2c_client
*client
,
409 const struct i2c_device_id
*id
)
411 const struct mms114_platform_data
*pdata
;
412 struct mms114_data
*data
;
413 struct input_dev
*input_dev
;
416 pdata
= dev_get_platdata(&client
->dev
);
418 pdata
= mms114_parse_dt(&client
->dev
);
421 dev_err(&client
->dev
, "Need platform data\n");
425 if (!i2c_check_functionality(client
->adapter
,
426 I2C_FUNC_PROTOCOL_MANGLING
)) {
427 dev_err(&client
->dev
,
428 "Need i2c bus that supports protocol mangling\n");
432 data
= devm_kzalloc(&client
->dev
, sizeof(struct mms114_data
),
434 input_dev
= devm_input_allocate_device(&client
->dev
);
435 if (!data
|| !input_dev
) {
436 dev_err(&client
->dev
, "Failed to allocate memory\n");
440 data
->client
= client
;
441 data
->input_dev
= input_dev
;
444 input_dev
->name
= "MELPAS MMS114 Touchscreen";
445 input_dev
->id
.bustype
= BUS_I2C
;
446 input_dev
->dev
.parent
= &client
->dev
;
447 input_dev
->open
= mms114_input_open
;
448 input_dev
->close
= mms114_input_close
;
450 __set_bit(EV_ABS
, input_dev
->evbit
);
451 __set_bit(EV_KEY
, input_dev
->evbit
);
452 __set_bit(BTN_TOUCH
, input_dev
->keybit
);
453 input_set_abs_params(input_dev
, ABS_X
, 0, data
->pdata
->x_size
, 0, 0);
454 input_set_abs_params(input_dev
, ABS_Y
, 0, data
->pdata
->y_size
, 0, 0);
456 /* For multi touch */
457 input_mt_init_slots(input_dev
, MMS114_MAX_TOUCH
, 0);
458 input_set_abs_params(input_dev
, ABS_MT_TOUCH_MAJOR
,
459 0, MMS114_MAX_AREA
, 0, 0);
460 input_set_abs_params(input_dev
, ABS_MT_POSITION_X
,
461 0, data
->pdata
->x_size
, 0, 0);
462 input_set_abs_params(input_dev
, ABS_MT_POSITION_Y
,
463 0, data
->pdata
->y_size
, 0, 0);
464 input_set_abs_params(input_dev
, ABS_MT_PRESSURE
, 0, 255, 0, 0);
466 input_set_drvdata(input_dev
, data
);
467 i2c_set_clientdata(client
, data
);
469 data
->core_reg
= devm_regulator_get(&client
->dev
, "avdd");
470 if (IS_ERR(data
->core_reg
)) {
471 error
= PTR_ERR(data
->core_reg
);
472 dev_err(&client
->dev
,
473 "Unable to get the Core regulator (%d)\n", error
);
477 data
->io_reg
= devm_regulator_get(&client
->dev
, "vdd");
478 if (IS_ERR(data
->io_reg
)) {
479 error
= PTR_ERR(data
->io_reg
);
480 dev_err(&client
->dev
,
481 "Unable to get the IO regulator (%d)\n", error
);
485 error
= devm_request_threaded_irq(&client
->dev
, client
->irq
, NULL
,
486 mms114_interrupt
, IRQF_TRIGGER_FALLING
| IRQF_ONESHOT
,
487 dev_name(&client
->dev
), data
);
489 dev_err(&client
->dev
, "Failed to register interrupt\n");
492 disable_irq(client
->irq
);
494 error
= input_register_device(data
->input_dev
);
496 dev_err(&client
->dev
, "Failed to register input device\n");
503 #ifdef CONFIG_PM_SLEEP
504 static int mms114_suspend(struct device
*dev
)
506 struct i2c_client
*client
= to_i2c_client(dev
);
507 struct mms114_data
*data
= i2c_get_clientdata(client
);
508 struct input_dev
*input_dev
= data
->input_dev
;
511 /* Release all touch */
512 for (id
= 0; id
< MMS114_MAX_TOUCH
; id
++) {
513 input_mt_slot(input_dev
, id
);
514 input_mt_report_slot_state(input_dev
, MT_TOOL_FINGER
, false);
517 input_mt_report_pointer_emulation(input_dev
, true);
518 input_sync(input_dev
);
520 mutex_lock(&input_dev
->mutex
);
521 if (input_dev
->users
)
523 mutex_unlock(&input_dev
->mutex
);
528 static int mms114_resume(struct device
*dev
)
530 struct i2c_client
*client
= to_i2c_client(dev
);
531 struct mms114_data
*data
= i2c_get_clientdata(client
);
532 struct input_dev
*input_dev
= data
->input_dev
;
535 mutex_lock(&input_dev
->mutex
);
536 if (input_dev
->users
) {
537 error
= mms114_start(data
);
539 mutex_unlock(&input_dev
->mutex
);
543 mutex_unlock(&input_dev
->mutex
);
549 static SIMPLE_DEV_PM_OPS(mms114_pm_ops
, mms114_suspend
, mms114_resume
);
551 static const struct i2c_device_id mms114_id
[] = {
555 MODULE_DEVICE_TABLE(i2c
, mms114_id
);
558 static struct of_device_id mms114_dt_match
[] = {
559 { .compatible
= "melfas,mms114" },
564 static struct i2c_driver mms114_driver
= {
567 .owner
= THIS_MODULE
,
568 .pm
= &mms114_pm_ops
,
569 .of_match_table
= of_match_ptr(mms114_dt_match
),
571 .probe
= mms114_probe
,
572 .id_table
= mms114_id
,
575 module_i2c_driver(mms114_driver
);
577 /* Module information */
578 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
579 MODULE_DESCRIPTION("MELFAS mms114 Touchscreen driver");
580 MODULE_LICENSE("GPL");