Commit | Line | Data |
---|---|---|
562b42d3 AD |
1 | /* |
2 | * Copyright (c) 2012-2016 Synaptics Incorporated | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify it | |
5 | * under the terms of the GNU General Public License version 2 as published by | |
6 | * the Free Software Foundation. | |
7 | */ | |
8 | ||
9 | #include <linux/kernel.h> | |
10 | #include <linux/rmi.h> | |
11 | #include <linux/input.h> | |
12 | #include <linux/slab.h> | |
13 | #include "rmi_driver.h" | |
14 | ||
15 | #define RMI_F30_QUERY_SIZE 2 | |
16 | ||
17 | /* Defs for Query 0 */ | |
18 | #define RMI_F30_EXTENDED_PATTERNS 0x01 | |
19 | #define RMI_F30_HAS_MAPPABLE_BUTTONS (1 << 1) | |
20 | #define RMI_F30_HAS_LED (1 << 2) | |
21 | #define RMI_F30_HAS_GPIO (1 << 3) | |
22 | #define RMI_F30_HAS_HAPTIC (1 << 4) | |
23 | #define RMI_F30_HAS_GPIO_DRV_CTL (1 << 5) | |
24 | #define RMI_F30_HAS_MECH_MOUSE_BTNS (1 << 6) | |
25 | ||
26 | /* Defs for Query 1 */ | |
27 | #define RMI_F30_GPIO_LED_COUNT 0x1F | |
28 | ||
29 | /* Defs for Control Registers */ | |
30 | #define RMI_F30_CTRL_1_GPIO_DEBOUNCE 0x01 | |
31 | #define RMI_F30_CTRL_1_HALT (1 << 4) | |
32 | #define RMI_F30_CTRL_1_HALTED (1 << 5) | |
33 | #define RMI_F30_CTRL_10_NUM_MECH_MOUSE_BTNS 0x03 | |
34 | ||
35 | struct rmi_f30_ctrl_data { | |
36 | int address; | |
37 | int length; | |
38 | u8 *regs; | |
39 | }; | |
40 | ||
41 | #define RMI_F30_CTRL_MAX_REGS 32 | |
42 | #define RMI_F30_CTRL_MAX_BYTES ((RMI_F30_CTRL_MAX_REGS + 7) >> 3) | |
43 | #define RMI_F30_CTRL_MAX_REG_BLOCKS 11 | |
44 | ||
45 | #define RMI_F30_CTRL_REGS_MAX_SIZE (RMI_F30_CTRL_MAX_BYTES \ | |
46 | + 1 \ | |
47 | + RMI_F30_CTRL_MAX_BYTES \ | |
48 | + RMI_F30_CTRL_MAX_BYTES \ | |
49 | + RMI_F30_CTRL_MAX_BYTES \ | |
50 | + 6 \ | |
51 | + RMI_F30_CTRL_MAX_REGS \ | |
52 | + RMI_F30_CTRL_MAX_REGS \ | |
53 | + RMI_F30_CTRL_MAX_BYTES \ | |
54 | + 1 \ | |
55 | + 1) | |
56 | ||
57 | struct f30_data { | |
58 | /* Query Data */ | |
59 | bool has_extended_pattern; | |
60 | bool has_mappable_buttons; | |
61 | bool has_led; | |
62 | bool has_gpio; | |
63 | bool has_haptic; | |
64 | bool has_gpio_driver_control; | |
65 | bool has_mech_mouse_btns; | |
66 | u8 gpioled_count; | |
67 | ||
68 | u8 register_count; | |
69 | ||
70 | /* Control Register Data */ | |
71 | struct rmi_f30_ctrl_data ctrl[RMI_F30_CTRL_MAX_REG_BLOCKS]; | |
72 | u8 ctrl_regs[RMI_F30_CTRL_REGS_MAX_SIZE]; | |
73 | u32 ctrl_regs_size; | |
74 | ||
75 | u8 data_regs[RMI_F30_CTRL_MAX_BYTES]; | |
76 | u16 *gpioled_key_map; | |
77 | ||
78 | struct input_dev *input; | |
79 | }; | |
80 | ||
81 | static int rmi_f30_read_control_parameters(struct rmi_function *fn, | |
82 | struct f30_data *f30) | |
83 | { | |
84 | struct rmi_device *rmi_dev = fn->rmi_dev; | |
85 | int error = 0; | |
86 | ||
87 | error = rmi_read_block(rmi_dev, fn->fd.control_base_addr, | |
88 | f30->ctrl_regs, f30->ctrl_regs_size); | |
89 | if (error) { | |
90 | dev_err(&rmi_dev->dev, "%s : Could not read control registers at 0x%x error (%d)\n", | |
91 | __func__, fn->fd.control_base_addr, error); | |
92 | return error; | |
93 | } | |
94 | ||
95 | return 0; | |
96 | } | |
97 | ||
98 | static int rmi_f30_attention(struct rmi_function *fn, unsigned long *irq_bits) | |
99 | { | |
100 | struct f30_data *f30 = dev_get_drvdata(&fn->dev); | |
101 | struct rmi_device *rmi_dev = fn->rmi_dev; | |
102 | int retval; | |
103 | int gpiled = 0; | |
104 | int value = 0; | |
105 | int i; | |
106 | int reg_num; | |
107 | ||
108 | if (!f30->input) | |
109 | return 0; | |
110 | ||
111 | /* Read the gpi led data. */ | |
112 | if (rmi_dev->xport->attn_data) { | |
113 | memcpy(f30->data_regs, rmi_dev->xport->attn_data, | |
114 | f30->register_count); | |
115 | rmi_dev->xport->attn_data += f30->register_count; | |
116 | rmi_dev->xport->attn_size -= f30->register_count; | |
117 | } else { | |
118 | retval = rmi_read_block(rmi_dev, fn->fd.data_base_addr, | |
119 | f30->data_regs, f30->register_count); | |
120 | ||
121 | if (retval) { | |
122 | dev_err(&fn->dev, "%s: Failed to read F30 data registers.\n", | |
123 | __func__); | |
124 | return retval; | |
125 | } | |
126 | } | |
127 | ||
128 | for (reg_num = 0; reg_num < f30->register_count; ++reg_num) { | |
129 | for (i = 0; gpiled < f30->gpioled_count && i < 8; ++i, | |
130 | ++gpiled) { | |
131 | if (f30->gpioled_key_map[gpiled] != 0) { | |
132 | /* buttons have pull up resistors */ | |
133 | value = (((f30->data_regs[reg_num] >> i) & 0x01) | |
134 | == 0); | |
135 | ||
136 | rmi_dbg(RMI_DEBUG_FN, &fn->dev, | |
137 | "%s: call input report key (0x%04x) value (0x%02x)", | |
138 | __func__, | |
139 | f30->gpioled_key_map[gpiled], value); | |
140 | input_report_key(f30->input, | |
141 | f30->gpioled_key_map[gpiled], | |
142 | value); | |
143 | } | |
144 | ||
145 | } | |
146 | } | |
147 | ||
148 | return 0; | |
149 | } | |
150 | ||
151 | static int rmi_f30_register_device(struct rmi_function *fn) | |
152 | { | |
153 | int i; | |
154 | struct rmi_device *rmi_dev = fn->rmi_dev; | |
155 | struct rmi_driver_data *drv_data = dev_get_drvdata(&rmi_dev->dev); | |
156 | struct f30_data *f30 = dev_get_drvdata(&fn->dev); | |
157 | struct input_dev *input_dev; | |
158 | int button_count = 0; | |
159 | ||
160 | input_dev = drv_data->input; | |
161 | if (!input_dev) { | |
162 | dev_info(&fn->dev, "F30: no input device found, ignoring.\n"); | |
163 | return -EINVAL; | |
164 | } | |
165 | ||
166 | f30->input = input_dev; | |
167 | ||
168 | set_bit(EV_KEY, input_dev->evbit); | |
169 | ||
170 | input_dev->keycode = f30->gpioled_key_map; | |
171 | input_dev->keycodesize = sizeof(u16); | |
172 | input_dev->keycodemax = f30->gpioled_count; | |
173 | ||
174 | for (i = 0; i < f30->gpioled_count; i++) { | |
175 | if (f30->gpioled_key_map[i] != 0) { | |
176 | input_set_capability(input_dev, EV_KEY, | |
177 | f30->gpioled_key_map[i]); | |
178 | button_count++; | |
179 | } | |
180 | } | |
181 | ||
182 | if (button_count == 1) | |
183 | __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit); | |
184 | return 0; | |
185 | } | |
186 | ||
187 | static int rmi_f30_config(struct rmi_function *fn) | |
188 | { | |
189 | struct f30_data *f30 = dev_get_drvdata(&fn->dev); | |
190 | struct rmi_driver *drv = fn->rmi_dev->driver; | |
191 | const struct rmi_device_platform_data *pdata = | |
192 | rmi_get_platform_data(fn->rmi_dev); | |
193 | int error; | |
194 | ||
195 | if (pdata->f30_data && pdata->f30_data->disable) { | |
196 | drv->clear_irq_bits(fn->rmi_dev, fn->irq_mask); | |
197 | } else { | |
198 | /* Write Control Register values back to device */ | |
199 | error = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr, | |
200 | f30->ctrl_regs, f30->ctrl_regs_size); | |
201 | if (error) { | |
202 | dev_err(&fn->rmi_dev->dev, | |
203 | "%s : Could not write control registers at 0x%x error (%d)\n", | |
204 | __func__, fn->fd.control_base_addr, error); | |
205 | return error; | |
206 | } | |
207 | ||
208 | drv->set_irq_bits(fn->rmi_dev, fn->irq_mask); | |
209 | } | |
210 | return 0; | |
211 | } | |
212 | ||
213 | static inline void rmi_f30_set_ctrl_data(struct rmi_f30_ctrl_data *ctrl, | |
214 | int *ctrl_addr, int len, u8 **reg) | |
215 | { | |
216 | ctrl->address = *ctrl_addr; | |
217 | ctrl->length = len; | |
218 | ctrl->regs = *reg; | |
219 | *ctrl_addr += len; | |
220 | *reg += len; | |
221 | } | |
222 | ||
223 | static inline bool rmi_f30_is_valid_button(int button, | |
224 | struct rmi_f30_ctrl_data *ctrl) | |
225 | { | |
226 | int byte_position = button >> 3; | |
227 | int bit_position = button & 0x07; | |
228 | ||
229 | /* | |
230 | * ctrl2 -> dir == 0 -> input mode | |
231 | * ctrl3 -> data == 1 -> actual button | |
232 | */ | |
233 | return !(ctrl[2].regs[byte_position] & BIT(bit_position)) && | |
234 | (ctrl[3].regs[byte_position] & BIT(bit_position)); | |
235 | } | |
236 | ||
237 | static inline int rmi_f30_initialize(struct rmi_function *fn) | |
238 | { | |
239 | struct f30_data *f30; | |
240 | struct rmi_device *rmi_dev = fn->rmi_dev; | |
241 | const struct rmi_device_platform_data *pdata; | |
242 | int retval = 0; | |
243 | int control_address; | |
244 | int i; | |
245 | int button; | |
246 | u8 buf[RMI_F30_QUERY_SIZE]; | |
247 | u8 *ctrl_reg; | |
248 | u8 *map_memory; | |
249 | ||
250 | f30 = devm_kzalloc(&fn->dev, sizeof(struct f30_data), | |
251 | GFP_KERNEL); | |
252 | if (!f30) | |
253 | return -ENOMEM; | |
254 | ||
255 | dev_set_drvdata(&fn->dev, f30); | |
256 | ||
257 | retval = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr, buf, | |
258 | RMI_F30_QUERY_SIZE); | |
259 | ||
260 | if (retval) { | |
261 | dev_err(&fn->dev, "Failed to read query register.\n"); | |
262 | return retval; | |
263 | } | |
264 | ||
265 | f30->has_extended_pattern = buf[0] & RMI_F30_EXTENDED_PATTERNS; | |
266 | f30->has_mappable_buttons = buf[0] & RMI_F30_HAS_MAPPABLE_BUTTONS; | |
267 | f30->has_led = buf[0] & RMI_F30_HAS_LED; | |
268 | f30->has_gpio = buf[0] & RMI_F30_HAS_GPIO; | |
269 | f30->has_haptic = buf[0] & RMI_F30_HAS_HAPTIC; | |
270 | f30->has_gpio_driver_control = buf[0] & RMI_F30_HAS_GPIO_DRV_CTL; | |
271 | f30->has_mech_mouse_btns = buf[0] & RMI_F30_HAS_MECH_MOUSE_BTNS; | |
272 | f30->gpioled_count = buf[1] & RMI_F30_GPIO_LED_COUNT; | |
273 | ||
274 | f30->register_count = (f30->gpioled_count + 7) >> 3; | |
275 | ||
276 | control_address = fn->fd.control_base_addr; | |
277 | ctrl_reg = f30->ctrl_regs; | |
278 | ||
279 | if (f30->has_gpio && f30->has_led) | |
280 | rmi_f30_set_ctrl_data(&f30->ctrl[0], &control_address, | |
281 | f30->register_count, &ctrl_reg); | |
282 | ||
283 | rmi_f30_set_ctrl_data(&f30->ctrl[1], &control_address, sizeof(u8), | |
284 | &ctrl_reg); | |
285 | ||
286 | if (f30->has_gpio) { | |
287 | rmi_f30_set_ctrl_data(&f30->ctrl[2], &control_address, | |
288 | f30->register_count, &ctrl_reg); | |
289 | ||
290 | rmi_f30_set_ctrl_data(&f30->ctrl[3], &control_address, | |
291 | f30->register_count, &ctrl_reg); | |
292 | } | |
293 | ||
294 | if (f30->has_led) { | |
295 | int ctrl5_len; | |
296 | ||
297 | rmi_f30_set_ctrl_data(&f30->ctrl[4], &control_address, | |
298 | f30->register_count, &ctrl_reg); | |
299 | ||
300 | if (f30->has_extended_pattern) | |
301 | ctrl5_len = 6; | |
302 | else | |
303 | ctrl5_len = 2; | |
304 | ||
305 | rmi_f30_set_ctrl_data(&f30->ctrl[5], &control_address, | |
306 | ctrl5_len, &ctrl_reg); | |
307 | } | |
308 | ||
309 | if (f30->has_led || f30->has_gpio_driver_control) { | |
310 | /* control 6 uses a byte per gpio/led */ | |
311 | rmi_f30_set_ctrl_data(&f30->ctrl[6], &control_address, | |
312 | f30->gpioled_count, &ctrl_reg); | |
313 | } | |
314 | ||
315 | if (f30->has_mappable_buttons) { | |
316 | /* control 7 uses a byte per gpio/led */ | |
317 | rmi_f30_set_ctrl_data(&f30->ctrl[7], &control_address, | |
318 | f30->gpioled_count, &ctrl_reg); | |
319 | } | |
320 | ||
321 | if (f30->has_haptic) { | |
322 | rmi_f30_set_ctrl_data(&f30->ctrl[8], &control_address, | |
323 | f30->register_count, &ctrl_reg); | |
324 | ||
325 | rmi_f30_set_ctrl_data(&f30->ctrl[9], &control_address, | |
326 | sizeof(u8), &ctrl_reg); | |
327 | } | |
328 | ||
329 | if (f30->has_mech_mouse_btns) | |
330 | rmi_f30_set_ctrl_data(&f30->ctrl[10], &control_address, | |
331 | sizeof(u8), &ctrl_reg); | |
332 | ||
333 | f30->ctrl_regs_size = ctrl_reg - f30->ctrl_regs | |
334 | ?: RMI_F30_CTRL_REGS_MAX_SIZE; | |
335 | ||
336 | retval = rmi_f30_read_control_parameters(fn, f30); | |
337 | if (retval < 0) { | |
338 | dev_err(&fn->dev, | |
339 | "Failed to initialize F19 control params.\n"); | |
340 | return retval; | |
341 | } | |
342 | ||
343 | map_memory = devm_kzalloc(&fn->dev, | |
344 | (f30->gpioled_count * (sizeof(u16))), | |
345 | GFP_KERNEL); | |
346 | if (!map_memory) { | |
347 | dev_err(&fn->dev, "Failed to allocate gpioled map memory.\n"); | |
348 | return -ENOMEM; | |
349 | } | |
350 | ||
351 | f30->gpioled_key_map = (u16 *)map_memory; | |
352 | ||
353 | pdata = rmi_get_platform_data(rmi_dev); | |
354 | if (pdata && f30->has_gpio) { | |
355 | button = BTN_LEFT; | |
356 | for (i = 0; i < f30->gpioled_count; i++) { | |
357 | if (rmi_f30_is_valid_button(i, f30->ctrl)) { | |
358 | f30->gpioled_key_map[i] = button++; | |
359 | ||
360 | /* | |
361 | * buttonpad might be given by | |
362 | * f30->has_mech_mouse_btns, but I am | |
363 | * not sure, so use only the pdata info | |
364 | */ | |
365 | if (pdata->f30_data && | |
366 | pdata->f30_data->buttonpad) | |
367 | break; | |
368 | } | |
369 | } | |
370 | } | |
371 | ||
372 | return 0; | |
373 | } | |
374 | ||
375 | static int rmi_f30_probe(struct rmi_function *fn) | |
376 | { | |
377 | int rc; | |
378 | const struct rmi_device_platform_data *pdata = | |
379 | rmi_get_platform_data(fn->rmi_dev); | |
380 | ||
381 | if (pdata->f30_data && pdata->f30_data->disable) | |
382 | return 0; | |
383 | ||
384 | rc = rmi_f30_initialize(fn); | |
385 | if (rc < 0) | |
386 | goto error_exit; | |
387 | ||
388 | rc = rmi_f30_register_device(fn); | |
389 | if (rc < 0) | |
390 | goto error_exit; | |
391 | ||
392 | return 0; | |
393 | ||
394 | error_exit: | |
395 | return rc; | |
396 | ||
397 | } | |
398 | ||
399 | struct rmi_function_handler rmi_f30_handler = { | |
400 | .driver = { | |
401 | .name = "rmi4_f30", | |
402 | }, | |
403 | .func = 0x30, | |
404 | .probe = rmi_f30_probe, | |
405 | .config = rmi_f30_config, | |
406 | .attention = rmi_f30_attention, | |
407 | }; |