]>
Commit | Line | Data |
---|---|---|
5a966261 TT |
1 | /* |
2 | * Wacom Penabled Driver for I2C | |
3 | * | |
8855f30c | 4 | * Copyright (c) 2011 - 2013 Tatsunosuke Tobita, Wacom. |
5a966261 TT |
5 | * <tobita.tatsunosuke@wacom.co.jp> |
6 | * | |
7 | * This program is free software; you can redistribute it | |
8 | * and/or modify it under the terms of the GNU General | |
9 | * Public License as published by the Free Software | |
10 | * Foundation; either version of 2 of the License, | |
11 | * or (at your option) any later version. | |
12 | */ | |
13 | ||
14 | #include <linux/module.h> | |
15 | #include <linux/input.h> | |
16 | #include <linux/i2c.h> | |
17 | #include <linux/slab.h> | |
18 | #include <linux/irq.h> | |
19 | #include <linux/interrupt.h> | |
20 | #include <linux/gpio.h> | |
21 | #include <asm/unaligned.h> | |
22 | ||
23 | #define WACOM_CMD_QUERY0 0x04 | |
24 | #define WACOM_CMD_QUERY1 0x00 | |
25 | #define WACOM_CMD_QUERY2 0x33 | |
26 | #define WACOM_CMD_QUERY3 0x02 | |
27 | #define WACOM_CMD_THROW0 0x05 | |
28 | #define WACOM_CMD_THROW1 0x00 | |
29 | #define WACOM_QUERY_SIZE 19 | |
5a966261 TT |
30 | |
31 | struct wacom_features { | |
32 | int x_max; | |
33 | int y_max; | |
34 | int pressure_max; | |
35 | char fw_version; | |
36 | }; | |
37 | ||
38 | struct wacom_i2c { | |
39 | struct i2c_client *client; | |
40 | struct input_dev *input; | |
5a966261 | 41 | u8 data[WACOM_QUERY_SIZE]; |
8855f30c TT |
42 | bool prox; |
43 | int tool; | |
5a966261 TT |
44 | }; |
45 | ||
46 | static int wacom_query_device(struct i2c_client *client, | |
47 | struct wacom_features *features) | |
48 | { | |
49 | int ret; | |
50 | u8 cmd1[] = { WACOM_CMD_QUERY0, WACOM_CMD_QUERY1, | |
51 | WACOM_CMD_QUERY2, WACOM_CMD_QUERY3 }; | |
52 | u8 cmd2[] = { WACOM_CMD_THROW0, WACOM_CMD_THROW1 }; | |
53 | u8 data[WACOM_QUERY_SIZE]; | |
54 | struct i2c_msg msgs[] = { | |
55 | { | |
56 | .addr = client->addr, | |
57 | .flags = 0, | |
58 | .len = sizeof(cmd1), | |
59 | .buf = cmd1, | |
60 | }, | |
61 | { | |
62 | .addr = client->addr, | |
63 | .flags = 0, | |
64 | .len = sizeof(cmd2), | |
65 | .buf = cmd2, | |
66 | }, | |
67 | { | |
68 | .addr = client->addr, | |
69 | .flags = I2C_M_RD, | |
70 | .len = sizeof(data), | |
71 | .buf = data, | |
72 | }, | |
73 | }; | |
74 | ||
75 | ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); | |
76 | if (ret < 0) | |
77 | return ret; | |
78 | if (ret != ARRAY_SIZE(msgs)) | |
79 | return -EIO; | |
80 | ||
81 | features->x_max = get_unaligned_le16(&data[3]); | |
82 | features->y_max = get_unaligned_le16(&data[5]); | |
83 | features->pressure_max = get_unaligned_le16(&data[11]); | |
84 | features->fw_version = get_unaligned_le16(&data[13]); | |
85 | ||
86 | dev_dbg(&client->dev, | |
87 | "x_max:%d, y_max:%d, pressure:%d, fw:%d\n", | |
88 | features->x_max, features->y_max, | |
89 | features->pressure_max, features->fw_version); | |
90 | ||
91 | return 0; | |
92 | } | |
93 | ||
5a966261 TT |
94 | static irqreturn_t wacom_i2c_irq(int irq, void *dev_id) |
95 | { | |
96 | struct wacom_i2c *wac_i2c = dev_id; | |
97 | struct input_dev *input = wac_i2c->input; | |
98 | u8 *data = wac_i2c->data; | |
99 | unsigned int x, y, pressure; | |
100 | unsigned char tsw, f1, f2, ers; | |
101 | int error; | |
102 | ||
d5687782 DT |
103 | error = i2c_master_recv(wac_i2c->client, |
104 | wac_i2c->data, sizeof(wac_i2c->data)); | |
105 | if (error < 0) | |
5a966261 TT |
106 | goto out; |
107 | ||
108 | tsw = data[3] & 0x01; | |
109 | ers = data[3] & 0x04; | |
110 | f1 = data[3] & 0x02; | |
111 | f2 = data[3] & 0x10; | |
112 | x = le16_to_cpup((__le16 *)&data[4]); | |
113 | y = le16_to_cpup((__le16 *)&data[6]); | |
114 | pressure = le16_to_cpup((__le16 *)&data[8]); | |
115 | ||
8855f30c TT |
116 | if (!wac_i2c->prox) |
117 | wac_i2c->tool = (data[3] & 0x0c) ? | |
118 | BTN_TOOL_RUBBER : BTN_TOOL_PEN; | |
119 | ||
120 | wac_i2c->prox = data[3] & 0x20; | |
121 | ||
5a966261 | 122 | input_report_key(input, BTN_TOUCH, tsw || ers); |
8855f30c | 123 | input_report_key(input, wac_i2c->tool, wac_i2c->prox); |
5a966261 TT |
124 | input_report_key(input, BTN_STYLUS, f1); |
125 | input_report_key(input, BTN_STYLUS2, f2); | |
126 | input_report_abs(input, ABS_X, x); | |
127 | input_report_abs(input, ABS_Y, y); | |
128 | input_report_abs(input, ABS_PRESSURE, pressure); | |
129 | input_sync(input); | |
130 | ||
131 | out: | |
132 | return IRQ_HANDLED; | |
133 | } | |
134 | ||
135 | static int wacom_i2c_open(struct input_dev *dev) | |
136 | { | |
137 | struct wacom_i2c *wac_i2c = input_get_drvdata(dev); | |
138 | struct i2c_client *client = wac_i2c->client; | |
5a966261 TT |
139 | |
140 | enable_irq(client->irq); | |
141 | ||
142 | return 0; | |
143 | } | |
144 | ||
145 | static void wacom_i2c_close(struct input_dev *dev) | |
146 | { | |
147 | struct wacom_i2c *wac_i2c = input_get_drvdata(dev); | |
148 | struct i2c_client *client = wac_i2c->client; | |
149 | ||
150 | disable_irq(client->irq); | |
151 | } | |
152 | ||
5298cc4c | 153 | static int wacom_i2c_probe(struct i2c_client *client, |
5a966261 TT |
154 | const struct i2c_device_id *id) |
155 | { | |
156 | struct wacom_i2c *wac_i2c; | |
157 | struct input_dev *input; | |
8830cb88 | 158 | struct wacom_features features = { 0 }; |
5a966261 TT |
159 | int error; |
160 | ||
161 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { | |
162 | dev_err(&client->dev, "i2c_check_functionality error\n"); | |
163 | return -EIO; | |
164 | } | |
165 | ||
5a966261 TT |
166 | error = wacom_query_device(client, &features); |
167 | if (error) | |
168 | return error; | |
169 | ||
170 | wac_i2c = kzalloc(sizeof(*wac_i2c), GFP_KERNEL); | |
171 | input = input_allocate_device(); | |
172 | if (!wac_i2c || !input) { | |
173 | error = -ENOMEM; | |
174 | goto err_free_mem; | |
175 | } | |
176 | ||
177 | wac_i2c->client = client; | |
178 | wac_i2c->input = input; | |
5a966261 TT |
179 | |
180 | input->name = "Wacom I2C Digitizer"; | |
181 | input->id.bustype = BUS_I2C; | |
182 | input->id.vendor = 0x56a; | |
183 | input->id.version = features.fw_version; | |
184 | input->dev.parent = &client->dev; | |
185 | input->open = wacom_i2c_open; | |
186 | input->close = wacom_i2c_close; | |
187 | ||
188 | input->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); | |
189 | ||
190 | __set_bit(BTN_TOOL_PEN, input->keybit); | |
191 | __set_bit(BTN_TOOL_RUBBER, input->keybit); | |
192 | __set_bit(BTN_STYLUS, input->keybit); | |
193 | __set_bit(BTN_STYLUS2, input->keybit); | |
194 | __set_bit(BTN_TOUCH, input->keybit); | |
195 | ||
196 | input_set_abs_params(input, ABS_X, 0, features.x_max, 0, 0); | |
197 | input_set_abs_params(input, ABS_Y, 0, features.y_max, 0, 0); | |
198 | input_set_abs_params(input, ABS_PRESSURE, | |
199 | 0, features.pressure_max, 0, 0); | |
200 | ||
201 | input_set_drvdata(input, wac_i2c); | |
202 | ||
203 | error = request_threaded_irq(client->irq, NULL, wacom_i2c_irq, | |
d5687782 | 204 | IRQF_TRIGGER_LOW | IRQF_ONESHOT, |
5a966261 TT |
205 | "wacom_i2c", wac_i2c); |
206 | if (error) { | |
207 | dev_err(&client->dev, | |
208 | "Failed to enable IRQ, error: %d\n", error); | |
209 | goto err_free_mem; | |
210 | } | |
211 | ||
212 | /* Disable the IRQ, we'll enable it in wac_i2c_open() */ | |
213 | disable_irq(client->irq); | |
214 | ||
215 | error = input_register_device(wac_i2c->input); | |
216 | if (error) { | |
217 | dev_err(&client->dev, | |
218 | "Failed to register input device, error: %d\n", error); | |
219 | goto err_free_irq; | |
220 | } | |
221 | ||
222 | i2c_set_clientdata(client, wac_i2c); | |
223 | return 0; | |
224 | ||
225 | err_free_irq: | |
226 | free_irq(client->irq, wac_i2c); | |
227 | err_free_mem: | |
228 | input_free_device(input); | |
229 | kfree(wac_i2c); | |
230 | ||
231 | return error; | |
232 | } | |
233 | ||
e2619cf7 | 234 | static int wacom_i2c_remove(struct i2c_client *client) |
5a966261 TT |
235 | { |
236 | struct wacom_i2c *wac_i2c = i2c_get_clientdata(client); | |
237 | ||
238 | free_irq(client->irq, wac_i2c); | |
239 | input_unregister_device(wac_i2c->input); | |
240 | kfree(wac_i2c); | |
241 | ||
242 | return 0; | |
243 | } | |
244 | ||
245 | #ifdef CONFIG_PM_SLEEP | |
246 | static int wacom_i2c_suspend(struct device *dev) | |
247 | { | |
248 | struct i2c_client *client = to_i2c_client(dev); | |
249 | ||
250 | disable_irq(client->irq); | |
251 | ||
252 | return 0; | |
253 | } | |
254 | ||
255 | static int wacom_i2c_resume(struct device *dev) | |
256 | { | |
257 | struct i2c_client *client = to_i2c_client(dev); | |
258 | ||
259 | enable_irq(client->irq); | |
260 | ||
261 | return 0; | |
262 | } | |
263 | #endif | |
264 | ||
265 | static SIMPLE_DEV_PM_OPS(wacom_i2c_pm, wacom_i2c_suspend, wacom_i2c_resume); | |
266 | ||
267 | static const struct i2c_device_id wacom_i2c_id[] = { | |
268 | { "WAC_I2C_EMR", 0 }, | |
269 | { }, | |
270 | }; | |
271 | MODULE_DEVICE_TABLE(i2c, wacom_i2c_id); | |
272 | ||
273 | static struct i2c_driver wacom_i2c_driver = { | |
274 | .driver = { | |
275 | .name = "wacom_i2c", | |
276 | .owner = THIS_MODULE, | |
277 | .pm = &wacom_i2c_pm, | |
278 | }, | |
279 | ||
280 | .probe = wacom_i2c_probe, | |
1cb0aa88 | 281 | .remove = wacom_i2c_remove, |
5a966261 TT |
282 | .id_table = wacom_i2c_id, |
283 | }; | |
284 | module_i2c_driver(wacom_i2c_driver); | |
285 | ||
286 | MODULE_AUTHOR("Tatsunosuke Tobita <tobita.tatsunosuke@wacom.co.jp>"); | |
287 | MODULE_DESCRIPTION("WACOM EMR I2C Driver"); | |
288 | MODULE_LICENSE("GPL"); |