1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Cypress StreetFighter Touchkey Driver
4  *
5  * Copyright (c) 2021 Yassine Oudjana <y.oudjana@protonmail.com>
6  */
7 
8 #include <linux/bitmap.h>
9 #include <linux/bitops.h>
10 #include <linux/device.h>
11 #include <linux/i2c.h>
12 #include <linux/input.h>
13 #include <linux/interrupt.h>
14 #include <linux/module.h>
15 #include <linux/pm.h>
16 #include <linux/regulator/consumer.h>
17 
18 #define CYPRESS_SF_DEV_NAME "cypress-sf"
19 
20 #define CYPRESS_SF_REG_BUTTON_STATUS	0x4a
21 
22 struct cypress_sf_data {
23 	struct i2c_client *client;
24 	struct input_dev *input_dev;
25 	struct regulator_bulk_data regulators[2];
26 	u32 *keycodes;
27 	unsigned long keystates;
28 	int num_keys;
29 };
30 
cypress_sf_irq_handler(int irq,void * devid)31 static irqreturn_t cypress_sf_irq_handler(int irq, void *devid)
32 {
33 	struct cypress_sf_data *touchkey = devid;
34 	unsigned long keystates, changed;
35 	bool new_state;
36 	int val, key;
37 
38 	val = i2c_smbus_read_byte_data(touchkey->client,
39 				       CYPRESS_SF_REG_BUTTON_STATUS);
40 	if (val < 0) {
41 		dev_err(&touchkey->client->dev,
42 			"Failed to read button status: %d", val);
43 		return IRQ_NONE;
44 	}
45 	keystates = val;
46 
47 	bitmap_xor(&changed, &keystates, &touchkey->keystates,
48 		   touchkey->num_keys);
49 
50 	for_each_set_bit(key, &changed, touchkey->num_keys) {
51 		new_state = keystates & BIT(key);
52 		dev_dbg(&touchkey->client->dev,
53 			"Key %d changed to %d", key, new_state);
54 		input_report_key(touchkey->input_dev,
55 				 touchkey->keycodes[key], new_state);
56 	}
57 
58 	input_sync(touchkey->input_dev);
59 	touchkey->keystates = keystates;
60 
61 	return IRQ_HANDLED;
62 }
63 
cypress_sf_disable_regulators(void * arg)64 static void cypress_sf_disable_regulators(void *arg)
65 {
66 	struct cypress_sf_data *touchkey = arg;
67 
68 	regulator_bulk_disable(ARRAY_SIZE(touchkey->regulators),
69 			       touchkey->regulators);
70 }
71 
cypress_sf_probe(struct i2c_client * client)72 static int cypress_sf_probe(struct i2c_client *client)
73 {
74 	struct cypress_sf_data *touchkey;
75 	int key, error;
76 
77 	touchkey = devm_kzalloc(&client->dev, sizeof(*touchkey), GFP_KERNEL);
78 	if (!touchkey)
79 		return -ENOMEM;
80 
81 	touchkey->client = client;
82 	i2c_set_clientdata(client, touchkey);
83 
84 	touchkey->regulators[0].supply = "vdd";
85 	touchkey->regulators[1].supply = "avdd";
86 
87 	error = devm_regulator_bulk_get(&client->dev,
88 					ARRAY_SIZE(touchkey->regulators),
89 					touchkey->regulators);
90 	if (error) {
91 		dev_err(&client->dev, "Failed to get regulators: %d\n", error);
92 		return error;
93 	}
94 
95 	touchkey->num_keys = device_property_read_u32_array(&client->dev,
96 							    "linux,keycodes",
97 							    NULL, 0);
98 	if (touchkey->num_keys < 0) {
99 		/* Default key count */
100 		touchkey->num_keys = 2;
101 	}
102 
103 	touchkey->keycodes = devm_kcalloc(&client->dev,
104 					  touchkey->num_keys,
105 					  sizeof(*touchkey->keycodes),
106 					  GFP_KERNEL);
107 	if (!touchkey->keycodes)
108 		return -ENOMEM;
109 
110 	error = device_property_read_u32_array(&client->dev, "linux,keycodes",
111 					       touchkey->keycodes,
112 					       touchkey->num_keys);
113 
114 	if (error) {
115 		dev_warn(&client->dev,
116 			 "Failed to read keycodes: %d, using defaults\n",
117 			 error);
118 
119 		/* Default keycodes */
120 		touchkey->keycodes[0] = KEY_BACK;
121 		touchkey->keycodes[1] = KEY_MENU;
122 	}
123 
124 	error = regulator_bulk_enable(ARRAY_SIZE(touchkey->regulators),
125 				      touchkey->regulators);
126 	if (error) {
127 		dev_err(&client->dev,
128 			"Failed to enable regulators: %d\n", error);
129 		return error;
130 	}
131 
132 	error = devm_add_action_or_reset(&client->dev,
133 					 cypress_sf_disable_regulators,
134 					 touchkey);
135 	if (error)
136 		return error;
137 
138 	touchkey->input_dev = devm_input_allocate_device(&client->dev);
139 	if (!touchkey->input_dev) {
140 		dev_err(&client->dev, "Failed to allocate input device\n");
141 		return -ENOMEM;
142 	}
143 
144 	touchkey->input_dev->name = CYPRESS_SF_DEV_NAME;
145 	touchkey->input_dev->id.bustype = BUS_I2C;
146 
147 	for (key = 0; key < touchkey->num_keys; ++key)
148 		input_set_capability(touchkey->input_dev,
149 				     EV_KEY, touchkey->keycodes[key]);
150 
151 	error = input_register_device(touchkey->input_dev);
152 	if (error) {
153 		dev_err(&client->dev,
154 			"Failed to register input device: %d\n", error);
155 		return error;
156 	}
157 
158 	error = devm_request_threaded_irq(&client->dev, client->irq,
159 					  NULL, cypress_sf_irq_handler,
160 					  IRQF_ONESHOT,
161 					  CYPRESS_SF_DEV_NAME, touchkey);
162 	if (error) {
163 		dev_err(&client->dev,
164 			"Failed to register threaded irq: %d", error);
165 		return error;
166 	}
167 
168 	return 0;
169 };
170 
cypress_sf_suspend(struct device * dev)171 static int cypress_sf_suspend(struct device *dev)
172 {
173 	struct i2c_client *client = to_i2c_client(dev);
174 	struct cypress_sf_data *touchkey = i2c_get_clientdata(client);
175 	int error;
176 
177 	disable_irq(client->irq);
178 
179 	error = regulator_bulk_disable(ARRAY_SIZE(touchkey->regulators),
180 				       touchkey->regulators);
181 	if (error) {
182 		dev_err(dev, "Failed to disable regulators: %d", error);
183 		enable_irq(client->irq);
184 		return error;
185 	}
186 
187 	return 0;
188 }
189 
cypress_sf_resume(struct device * dev)190 static int cypress_sf_resume(struct device *dev)
191 {
192 	struct i2c_client *client = to_i2c_client(dev);
193 	struct cypress_sf_data *touchkey = i2c_get_clientdata(client);
194 	int error;
195 
196 	error = regulator_bulk_enable(ARRAY_SIZE(touchkey->regulators),
197 				      touchkey->regulators);
198 	if (error) {
199 		dev_err(dev, "Failed to enable regulators: %d", error);
200 		return error;
201 	}
202 
203 	enable_irq(client->irq);
204 
205 	return 0;
206 }
207 
208 static DEFINE_SIMPLE_DEV_PM_OPS(cypress_sf_pm_ops,
209 				cypress_sf_suspend, cypress_sf_resume);
210 
211 static struct i2c_device_id cypress_sf_id_table[] = {
212 	{ CYPRESS_SF_DEV_NAME, 0 },
213 	{ }
214 };
215 MODULE_DEVICE_TABLE(i2c, cypress_sf_id_table);
216 
217 #ifdef CONFIG_OF
218 static const struct of_device_id cypress_sf_of_match[] = {
219 	{ .compatible = "cypress,sf3155", },
220 	{ },
221 };
222 MODULE_DEVICE_TABLE(of, cypress_sf_of_match);
223 #endif
224 
225 static struct i2c_driver cypress_sf_driver = {
226 	.driver = {
227 		.name = CYPRESS_SF_DEV_NAME,
228 		.pm = pm_sleep_ptr(&cypress_sf_pm_ops),
229 		.of_match_table = of_match_ptr(cypress_sf_of_match),
230 	},
231 	.id_table = cypress_sf_id_table,
232 	.probe = cypress_sf_probe,
233 };
234 module_i2c_driver(cypress_sf_driver);
235 
236 MODULE_AUTHOR("Yassine Oudjana <y.oudjana@protonmail.com>");
237 MODULE_DESCRIPTION("Cypress StreetFighter Touchkey Driver");
238 MODULE_LICENSE("GPL v2");
239