1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/bitops.h>
16#include <linux/delay.h>
17#include <linux/device.h>
18#include <linux/i2c.h>
19#include <linux/input.h>
20#include <linux/interrupt.h>
21#include <linux/irq.h>
22#include <linux/leds.h>
23#include <linux/module.h>
24#include <linux/of.h>
25#include <linux/pm.h>
26#include <linux/regulator/consumer.h>
27
28#define TM2_TOUCHKEY_DEV_NAME "tm2-touchkey"
29#define TM2_TOUCHKEY_KEYCODE_REG 0x03
30#define TM2_TOUCHKEY_BASE_REG 0x00
31#define TM2_TOUCHKEY_CMD_LED_ON 0x10
32#define TM2_TOUCHKEY_CMD_LED_OFF 0x20
33#define TM2_TOUCHKEY_BIT_PRESS_EV BIT(3)
34#define TM2_TOUCHKEY_BIT_KEYCODE GENMASK(2, 0)
35#define TM2_TOUCHKEY_LED_VOLTAGE_MIN 2500000
36#define TM2_TOUCHKEY_LED_VOLTAGE_MAX 3300000
37
38enum {
39 TM2_TOUCHKEY_KEY_MENU = 0x1,
40 TM2_TOUCHKEY_KEY_BACK,
41};
42
43struct tm2_touchkey_data {
44 struct i2c_client *client;
45 struct input_dev *input_dev;
46 struct led_classdev led_dev;
47 struct regulator *vdd;
48 struct regulator_bulk_data regulators[2];
49};
50
51static void tm2_touchkey_led_brightness_set(struct led_classdev *led_dev,
52 enum led_brightness brightness)
53{
54 struct tm2_touchkey_data *touchkey =
55 container_of(led_dev, struct tm2_touchkey_data, led_dev);
56 u32 volt;
57 u8 data;
58
59 if (brightness == LED_OFF) {
60 volt = TM2_TOUCHKEY_LED_VOLTAGE_MIN;
61 data = TM2_TOUCHKEY_CMD_LED_OFF;
62 } else {
63 volt = TM2_TOUCHKEY_LED_VOLTAGE_MAX;
64 data = TM2_TOUCHKEY_CMD_LED_ON;
65 }
66
67 regulator_set_voltage(touchkey->vdd, volt, volt);
68 i2c_smbus_write_byte_data(touchkey->client,
69 TM2_TOUCHKEY_BASE_REG, data);
70}
71
72static int tm2_touchkey_power_enable(struct tm2_touchkey_data *touchkey)
73{
74 int error;
75
76 error = regulator_bulk_enable(ARRAY_SIZE(touchkey->regulators),
77 touchkey->regulators);
78 if (error)
79 return error;
80
81
82 msleep(150);
83
84 return 0;
85}
86
87static void tm2_touchkey_power_disable(void *data)
88{
89 struct tm2_touchkey_data *touchkey = data;
90
91 regulator_bulk_disable(ARRAY_SIZE(touchkey->regulators),
92 touchkey->regulators);
93}
94
95static irqreturn_t tm2_touchkey_irq_handler(int irq, void *devid)
96{
97 struct tm2_touchkey_data *touchkey = devid;
98 int data;
99 int key;
100
101 data = i2c_smbus_read_byte_data(touchkey->client,
102 TM2_TOUCHKEY_KEYCODE_REG);
103 if (data < 0) {
104 dev_err(&touchkey->client->dev,
105 "failed to read i2c data: %d\n", data);
106 goto out;
107 }
108
109 switch (data & TM2_TOUCHKEY_BIT_KEYCODE) {
110 case TM2_TOUCHKEY_KEY_MENU:
111 key = KEY_PHONE;
112 break;
113
114 case TM2_TOUCHKEY_KEY_BACK:
115 key = KEY_BACK;
116 break;
117
118 default:
119 dev_warn(&touchkey->client->dev,
120 "unhandled keycode, data %#02x\n", data);
121 goto out;
122 }
123
124 if (data & TM2_TOUCHKEY_BIT_PRESS_EV) {
125 input_report_key(touchkey->input_dev, KEY_PHONE, 0);
126 input_report_key(touchkey->input_dev, KEY_BACK, 0);
127 } else {
128 input_report_key(touchkey->input_dev, key, 1);
129 }
130
131 input_sync(touchkey->input_dev);
132
133out:
134 return IRQ_HANDLED;
135}
136
137static int tm2_touchkey_probe(struct i2c_client *client,
138 const struct i2c_device_id *id)
139{
140 struct tm2_touchkey_data *touchkey;
141 int error;
142
143 if (!i2c_check_functionality(client->adapter,
144 I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA)) {
145 dev_err(&client->dev, "incompatible I2C adapter\n");
146 return -EIO;
147 }
148
149 touchkey = devm_kzalloc(&client->dev, sizeof(*touchkey), GFP_KERNEL);
150 if (!touchkey)
151 return -ENOMEM;
152
153 touchkey->client = client;
154 i2c_set_clientdata(client, touchkey);
155
156 touchkey->regulators[0].supply = "vcc";
157 touchkey->regulators[1].supply = "vdd";
158 error = devm_regulator_bulk_get(&client->dev,
159 ARRAY_SIZE(touchkey->regulators),
160 touchkey->regulators);
161 if (error) {
162 dev_err(&client->dev, "failed to get regulators: %d\n", error);
163 return error;
164 }
165
166
167 touchkey->vdd = touchkey->regulators[1].consumer;
168
169 error = tm2_touchkey_power_enable(touchkey);
170 if (error) {
171 dev_err(&client->dev, "failed to power up device: %d\n", error);
172 return error;
173 }
174
175 error = devm_add_action_or_reset(&client->dev,
176 tm2_touchkey_power_disable, touchkey);
177 if (error) {
178 dev_err(&client->dev,
179 "failed to install poweroff handler: %d\n", error);
180 return error;
181 }
182
183
184 touchkey->input_dev = devm_input_allocate_device(&client->dev);
185 if (!touchkey->input_dev) {
186 dev_err(&client->dev, "failed to allocate input device\n");
187 return -ENOMEM;
188 }
189
190 touchkey->input_dev->name = TM2_TOUCHKEY_DEV_NAME;
191 touchkey->input_dev->id.bustype = BUS_I2C;
192
193 input_set_capability(touchkey->input_dev, EV_KEY, KEY_PHONE);
194 input_set_capability(touchkey->input_dev, EV_KEY, KEY_BACK);
195
196 error = input_register_device(touchkey->input_dev);
197 if (error) {
198 dev_err(&client->dev,
199 "failed to register input device: %d\n", error);
200 return error;
201 }
202
203 error = devm_request_threaded_irq(&client->dev, client->irq,
204 NULL, tm2_touchkey_irq_handler,
205 IRQF_ONESHOT,
206 TM2_TOUCHKEY_DEV_NAME, touchkey);
207 if (error) {
208 dev_err(&client->dev,
209 "failed to request threaded irq: %d\n", error);
210 return error;
211 }
212
213
214 touchkey->led_dev.name = TM2_TOUCHKEY_DEV_NAME;
215 touchkey->led_dev.brightness = LED_FULL;
216 touchkey->led_dev.max_brightness = LED_ON;
217 touchkey->led_dev.brightness_set = tm2_touchkey_led_brightness_set;
218
219 error = devm_led_classdev_register(&client->dev, &touchkey->led_dev);
220 if (error) {
221 dev_err(&client->dev,
222 "failed to register touchkey led: %d\n", error);
223 return error;
224 }
225
226 return 0;
227}
228
229static int __maybe_unused tm2_touchkey_suspend(struct device *dev)
230{
231 struct i2c_client *client = to_i2c_client(dev);
232 struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client);
233
234 disable_irq(client->irq);
235 tm2_touchkey_power_disable(touchkey);
236
237 return 0;
238}
239
240static int __maybe_unused tm2_touchkey_resume(struct device *dev)
241{
242 struct i2c_client *client = to_i2c_client(dev);
243 struct tm2_touchkey_data *touchkey = i2c_get_clientdata(client);
244 int ret;
245
246 enable_irq(client->irq);
247
248 ret = tm2_touchkey_power_enable(touchkey);
249 if (ret)
250 dev_err(dev, "failed to enable power: %d\n", ret);
251
252 return ret;
253}
254
255static SIMPLE_DEV_PM_OPS(tm2_touchkey_pm_ops,
256 tm2_touchkey_suspend, tm2_touchkey_resume);
257
258static const struct i2c_device_id tm2_touchkey_id_table[] = {
259 { TM2_TOUCHKEY_DEV_NAME, 0 },
260 { },
261};
262MODULE_DEVICE_TABLE(i2c, tm2_touchkey_id_table);
263
264static const struct of_device_id tm2_touchkey_of_match[] = {
265 { .compatible = "cypress,tm2-touchkey", },
266 { },
267};
268MODULE_DEVICE_TABLE(of, tm2_touchkey_of_match);
269
270static struct i2c_driver tm2_touchkey_driver = {
271 .driver = {
272 .name = TM2_TOUCHKEY_DEV_NAME,
273 .pm = &tm2_touchkey_pm_ops,
274 .of_match_table = of_match_ptr(tm2_touchkey_of_match),
275 },
276 .probe = tm2_touchkey_probe,
277 .id_table = tm2_touchkey_id_table,
278};
279module_i2c_driver(tm2_touchkey_driver);
280
281MODULE_AUTHOR("Beomho Seo <beomho.seo@samsung.com>");
282MODULE_AUTHOR("Jaechul Lee <jcsing.lee@samsung.com>");
283MODULE_DESCRIPTION("Samsung touchkey driver");
284MODULE_LICENSE("GPL v2");
285
