This source file includes following definitions.
- rmi_f30_read_control_parameters
- rmi_f30_report_button
- rmi_f30_attention
- rmi_f30_config
- rmi_f30_set_ctrl_data
- rmi_f30_is_valid_button
- rmi_f30_map_gpios
- rmi_f30_initialize
- rmi_f30_probe
1
2
3
4
5
6 #include <linux/kernel.h>
7 #include <linux/rmi.h>
8 #include <linux/input.h>
9 #include <linux/slab.h>
10 #include "rmi_driver.h"
11
12 #define RMI_F30_QUERY_SIZE 2
13
14
15 #define RMI_F30_EXTENDED_PATTERNS 0x01
16 #define RMI_F30_HAS_MAPPABLE_BUTTONS BIT(1)
17 #define RMI_F30_HAS_LED BIT(2)
18 #define RMI_F30_HAS_GPIO BIT(3)
19 #define RMI_F30_HAS_HAPTIC BIT(4)
20 #define RMI_F30_HAS_GPIO_DRV_CTL BIT(5)
21 #define RMI_F30_HAS_MECH_MOUSE_BTNS BIT(6)
22
23
24 #define RMI_F30_GPIO_LED_COUNT 0x1F
25
26
27 #define RMI_F30_CTRL_1_GPIO_DEBOUNCE 0x01
28 #define RMI_F30_CTRL_1_HALT BIT(4)
29 #define RMI_F30_CTRL_1_HALTED BIT(5)
30 #define RMI_F30_CTRL_10_NUM_MECH_MOUSE_BTNS 0x03
31
32 #define RMI_F30_CTRL_MAX_REGS 32
33 #define RMI_F30_CTRL_MAX_BYTES DIV_ROUND_UP(RMI_F30_CTRL_MAX_REGS, 8)
34 #define RMI_F30_CTRL_MAX_REG_BLOCKS 11
35
36 #define RMI_F30_CTRL_REGS_MAX_SIZE (RMI_F30_CTRL_MAX_BYTES \
37 + 1 \
38 + RMI_F30_CTRL_MAX_BYTES \
39 + RMI_F30_CTRL_MAX_BYTES \
40 + RMI_F30_CTRL_MAX_BYTES \
41 + 6 \
42 + RMI_F30_CTRL_MAX_REGS \
43 + RMI_F30_CTRL_MAX_REGS \
44 + RMI_F30_CTRL_MAX_BYTES \
45 + 1 \
46 + 1)
47
48 #define TRACKSTICK_RANGE_START 3
49 #define TRACKSTICK_RANGE_END 6
50
51 struct rmi_f30_ctrl_data {
52 int address;
53 int length;
54 u8 *regs;
55 };
56
57 struct f30_data {
58
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
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 struct rmi_function *f03;
81 bool trackstick_buttons;
82 };
83
84 static int rmi_f30_read_control_parameters(struct rmi_function *fn,
85 struct f30_data *f30)
86 {
87 int error;
88
89 error = rmi_read_block(fn->rmi_dev, fn->fd.control_base_addr,
90 f30->ctrl_regs, f30->ctrl_regs_size);
91 if (error) {
92 dev_err(&fn->dev,
93 "%s: Could not read control registers at 0x%x: %d\n",
94 __func__, fn->fd.control_base_addr, error);
95 return error;
96 }
97
98 return 0;
99 }
100
101 static void rmi_f30_report_button(struct rmi_function *fn,
102 struct f30_data *f30, unsigned int button)
103 {
104 unsigned int reg_num = button >> 3;
105 unsigned int bit_num = button & 0x07;
106 u16 key_code = f30->gpioled_key_map[button];
107 bool key_down = !(f30->data_regs[reg_num] & BIT(bit_num));
108
109 if (f30->trackstick_buttons &&
110 button >= TRACKSTICK_RANGE_START &&
111 button <= TRACKSTICK_RANGE_END) {
112 rmi_f03_overwrite_button(f30->f03, key_code, key_down);
113 } else {
114 rmi_dbg(RMI_DEBUG_FN, &fn->dev,
115 "%s: call input report key (0x%04x) value (0x%02x)",
116 __func__, key_code, key_down);
117
118 input_report_key(f30->input, key_code, key_down);
119 }
120 }
121
122 static irqreturn_t rmi_f30_attention(int irq, void *ctx)
123 {
124 struct rmi_function *fn = ctx;
125 struct f30_data *f30 = dev_get_drvdata(&fn->dev);
126 struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev);
127 int error;
128 int i;
129
130
131 if (drvdata->attn_data.data) {
132 if (drvdata->attn_data.size < f30->register_count) {
133 dev_warn(&fn->dev,
134 "F30 interrupted, but data is missing\n");
135 return IRQ_HANDLED;
136 }
137 memcpy(f30->data_regs, drvdata->attn_data.data,
138 f30->register_count);
139 drvdata->attn_data.data += f30->register_count;
140 drvdata->attn_data.size -= f30->register_count;
141 } else {
142 error = rmi_read_block(fn->rmi_dev, fn->fd.data_base_addr,
143 f30->data_regs, f30->register_count);
144 if (error) {
145 dev_err(&fn->dev,
146 "%s: Failed to read F30 data registers: %d\n",
147 __func__, error);
148 return IRQ_RETVAL(error);
149 }
150 }
151
152 if (f30->has_gpio) {
153 for (i = 0; i < f30->gpioled_count; i++)
154 if (f30->gpioled_key_map[i] != KEY_RESERVED)
155 rmi_f30_report_button(fn, f30, i);
156 if (f30->trackstick_buttons)
157 rmi_f03_commit_buttons(f30->f03);
158 }
159
160 return IRQ_HANDLED;
161 }
162
163 static int rmi_f30_config(struct rmi_function *fn)
164 {
165 struct f30_data *f30 = dev_get_drvdata(&fn->dev);
166 struct rmi_driver *drv = fn->rmi_dev->driver;
167 const struct rmi_device_platform_data *pdata =
168 rmi_get_platform_data(fn->rmi_dev);
169 int error;
170
171
172 if (!f30)
173 return 0;
174
175 if (pdata->f30_data.trackstick_buttons) {
176
177 f30->f03 = rmi_find_function(fn->rmi_dev, 0x03);
178 f30->trackstick_buttons = f30->f03 != NULL;
179 }
180
181 if (pdata->f30_data.disable) {
182 drv->clear_irq_bits(fn->rmi_dev, fn->irq_mask);
183 } else {
184
185 error = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
186 f30->ctrl_regs, f30->ctrl_regs_size);
187 if (error) {
188 dev_err(&fn->dev,
189 "%s: Could not write control registers at 0x%x: %d\n",
190 __func__, fn->fd.control_base_addr, error);
191 return error;
192 }
193
194 drv->set_irq_bits(fn->rmi_dev, fn->irq_mask);
195 }
196
197 return 0;
198 }
199
200 static void rmi_f30_set_ctrl_data(struct rmi_f30_ctrl_data *ctrl,
201 int *ctrl_addr, int len, u8 **reg)
202 {
203 ctrl->address = *ctrl_addr;
204 ctrl->length = len;
205 ctrl->regs = *reg;
206 *ctrl_addr += len;
207 *reg += len;
208 }
209
210 static bool rmi_f30_is_valid_button(int button, struct rmi_f30_ctrl_data *ctrl)
211 {
212 int byte_position = button >> 3;
213 int bit_position = button & 0x07;
214
215
216
217
218
219 return !(ctrl[2].regs[byte_position] & BIT(bit_position)) &&
220 (ctrl[3].regs[byte_position] & BIT(bit_position));
221 }
222
223 static int rmi_f30_map_gpios(struct rmi_function *fn,
224 struct f30_data *f30)
225 {
226 const struct rmi_device_platform_data *pdata =
227 rmi_get_platform_data(fn->rmi_dev);
228 struct input_dev *input = f30->input;
229 unsigned int button = BTN_LEFT;
230 unsigned int trackstick_button = BTN_LEFT;
231 bool button_mapped = false;
232 int i;
233 int button_count = min_t(u8, f30->gpioled_count, TRACKSTICK_RANGE_END);
234
235 f30->gpioled_key_map = devm_kcalloc(&fn->dev,
236 button_count,
237 sizeof(f30->gpioled_key_map[0]),
238 GFP_KERNEL);
239 if (!f30->gpioled_key_map) {
240 dev_err(&fn->dev, "Failed to allocate gpioled map memory.\n");
241 return -ENOMEM;
242 }
243
244 for (i = 0; i < button_count; i++) {
245 if (!rmi_f30_is_valid_button(i, f30->ctrl))
246 continue;
247
248 if (pdata->f30_data.trackstick_buttons &&
249 i >= TRACKSTICK_RANGE_START && i < TRACKSTICK_RANGE_END) {
250 f30->gpioled_key_map[i] = trackstick_button++;
251 } else if (!pdata->f30_data.buttonpad || !button_mapped) {
252 f30->gpioled_key_map[i] = button;
253 input_set_capability(input, EV_KEY, button++);
254 button_mapped = true;
255 }
256 }
257
258 input->keycode = f30->gpioled_key_map;
259 input->keycodesize = sizeof(f30->gpioled_key_map[0]);
260 input->keycodemax = f30->gpioled_count;
261
262
263
264
265
266
267 if (pdata->f30_data.buttonpad || (button - BTN_LEFT == 1))
268 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
269
270 return 0;
271 }
272
273 static int rmi_f30_initialize(struct rmi_function *fn, struct f30_data *f30)
274 {
275 u8 *ctrl_reg = f30->ctrl_regs;
276 int control_address = fn->fd.control_base_addr;
277 u8 buf[RMI_F30_QUERY_SIZE];
278 int error;
279
280 error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr,
281 buf, RMI_F30_QUERY_SIZE);
282 if (error) {
283 dev_err(&fn->dev, "Failed to read query register\n");
284 return error;
285 }
286
287 f30->has_extended_pattern = buf[0] & RMI_F30_EXTENDED_PATTERNS;
288 f30->has_mappable_buttons = buf[0] & RMI_F30_HAS_MAPPABLE_BUTTONS;
289 f30->has_led = buf[0] & RMI_F30_HAS_LED;
290 f30->has_gpio = buf[0] & RMI_F30_HAS_GPIO;
291 f30->has_haptic = buf[0] & RMI_F30_HAS_HAPTIC;
292 f30->has_gpio_driver_control = buf[0] & RMI_F30_HAS_GPIO_DRV_CTL;
293 f30->has_mech_mouse_btns = buf[0] & RMI_F30_HAS_MECH_MOUSE_BTNS;
294 f30->gpioled_count = buf[1] & RMI_F30_GPIO_LED_COUNT;
295
296 f30->register_count = DIV_ROUND_UP(f30->gpioled_count, 8);
297
298 if (f30->has_gpio && f30->has_led)
299 rmi_f30_set_ctrl_data(&f30->ctrl[0], &control_address,
300 f30->register_count, &ctrl_reg);
301
302 rmi_f30_set_ctrl_data(&f30->ctrl[1], &control_address,
303 sizeof(u8), &ctrl_reg);
304
305 if (f30->has_gpio) {
306 rmi_f30_set_ctrl_data(&f30->ctrl[2], &control_address,
307 f30->register_count, &ctrl_reg);
308
309 rmi_f30_set_ctrl_data(&f30->ctrl[3], &control_address,
310 f30->register_count, &ctrl_reg);
311 }
312
313 if (f30->has_led) {
314 rmi_f30_set_ctrl_data(&f30->ctrl[4], &control_address,
315 f30->register_count, &ctrl_reg);
316
317 rmi_f30_set_ctrl_data(&f30->ctrl[5], &control_address,
318 f30->has_extended_pattern ? 6 : 2,
319 &ctrl_reg);
320 }
321
322 if (f30->has_led || f30->has_gpio_driver_control) {
323
324 rmi_f30_set_ctrl_data(&f30->ctrl[6], &control_address,
325 f30->gpioled_count, &ctrl_reg);
326 }
327
328 if (f30->has_mappable_buttons) {
329
330 rmi_f30_set_ctrl_data(&f30->ctrl[7], &control_address,
331 f30->gpioled_count, &ctrl_reg);
332 }
333
334 if (f30->has_haptic) {
335 rmi_f30_set_ctrl_data(&f30->ctrl[8], &control_address,
336 f30->register_count, &ctrl_reg);
337
338 rmi_f30_set_ctrl_data(&f30->ctrl[9], &control_address,
339 sizeof(u8), &ctrl_reg);
340 }
341
342 if (f30->has_mech_mouse_btns)
343 rmi_f30_set_ctrl_data(&f30->ctrl[10], &control_address,
344 sizeof(u8), &ctrl_reg);
345
346 f30->ctrl_regs_size = ctrl_reg -
347 f30->ctrl_regs ?: RMI_F30_CTRL_REGS_MAX_SIZE;
348
349 error = rmi_f30_read_control_parameters(fn, f30);
350 if (error) {
351 dev_err(&fn->dev,
352 "Failed to initialize F30 control params: %d\n",
353 error);
354 return error;
355 }
356
357 if (f30->has_gpio) {
358 error = rmi_f30_map_gpios(fn, f30);
359 if (error)
360 return error;
361 }
362
363 return 0;
364 }
365
366 static int rmi_f30_probe(struct rmi_function *fn)
367 {
368 struct rmi_device *rmi_dev = fn->rmi_dev;
369 const struct rmi_device_platform_data *pdata =
370 rmi_get_platform_data(rmi_dev);
371 struct rmi_driver_data *drv_data = dev_get_drvdata(&rmi_dev->dev);
372 struct f30_data *f30;
373 int error;
374
375 if (pdata->f30_data.disable)
376 return 0;
377
378 if (!drv_data->input) {
379 dev_info(&fn->dev, "F30: no input device found, ignoring\n");
380 return -ENXIO;
381 }
382
383 f30 = devm_kzalloc(&fn->dev, sizeof(*f30), GFP_KERNEL);
384 if (!f30)
385 return -ENOMEM;
386
387 f30->input = drv_data->input;
388
389 error = rmi_f30_initialize(fn, f30);
390 if (error)
391 return error;
392
393 dev_set_drvdata(&fn->dev, f30);
394 return 0;
395 }
396
397 struct rmi_function_handler rmi_f30_handler = {
398 .driver = {
399 .name = "rmi4_f30",
400 },
401 .func = 0x30,
402 .probe = rmi_f30_probe,
403 .config = rmi_f30_config,
404 .attention = rmi_f30_attention,
405 };