Commit | Line | Data |
---|---|---|
2b6a321d AD |
1 | /* |
2 | * Copyright (c) 2011-2016 Synaptics Incorporated | |
3 | * Copyright (c) 2011 Unixphere | |
4 | * | |
5 | * This driver provides the core support for a single RMI4-based device. | |
6 | * | |
7 | * The RMI4 specification can be found here (URL split for line length): | |
8 | * | |
9 | * http://www.synaptics.com/sites/default/files/ | |
10 | * 511-000136-01-Rev-E-RMI4-Interfacing-Guide.pdf | |
11 | * | |
12 | * This program is free software; you can redistribute it and/or modify it | |
13 | * under the terms of the GNU General Public License version 2 as published by | |
14 | * the Free Software Foundation. | |
15 | */ | |
16 | ||
17 | #include <linux/bitmap.h> | |
18 | #include <linux/delay.h> | |
19 | #include <linux/fs.h> | |
20 | #include <linux/kconfig.h> | |
21 | #include <linux/pm.h> | |
22 | #include <linux/slab.h> | |
d8a8b3ed | 23 | #include <linux/of.h> |
2b6a321d AD |
24 | #include <uapi/linux/input.h> |
25 | #include <linux/rmi.h> | |
26 | #include "rmi_bus.h" | |
27 | #include "rmi_driver.h" | |
28 | ||
29 | #define HAS_NONSTANDARD_PDT_MASK 0x40 | |
30 | #define RMI4_MAX_PAGE 0xff | |
31 | #define RMI4_PAGE_SIZE 0x100 | |
32 | #define RMI4_PAGE_MASK 0xFF00 | |
33 | ||
34 | #define RMI_DEVICE_RESET_CMD 0x01 | |
35 | #define DEFAULT_RESET_DELAY_MS 100 | |
36 | ||
37 | static void rmi_free_function_list(struct rmi_device *rmi_dev) | |
38 | { | |
39 | struct rmi_function *fn, *tmp; | |
40 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
41 | ||
42 | data->f01_container = NULL; | |
43 | ||
44 | /* Doing it in the reverse order so F01 will be removed last */ | |
45 | list_for_each_entry_safe_reverse(fn, tmp, | |
46 | &data->function_list, node) { | |
47 | list_del(&fn->node); | |
48 | rmi_unregister_function(fn); | |
49 | } | |
50 | } | |
51 | ||
52 | static int reset_one_function(struct rmi_function *fn) | |
53 | { | |
54 | struct rmi_function_handler *fh; | |
55 | int retval = 0; | |
56 | ||
57 | if (!fn || !fn->dev.driver) | |
58 | return 0; | |
59 | ||
60 | fh = to_rmi_function_handler(fn->dev.driver); | |
61 | if (fh->reset) { | |
62 | retval = fh->reset(fn); | |
63 | if (retval < 0) | |
64 | dev_err(&fn->dev, "Reset failed with code %d.\n", | |
65 | retval); | |
66 | } | |
67 | ||
68 | return retval; | |
69 | } | |
70 | ||
71 | static int configure_one_function(struct rmi_function *fn) | |
72 | { | |
73 | struct rmi_function_handler *fh; | |
74 | int retval = 0; | |
75 | ||
76 | if (!fn || !fn->dev.driver) | |
77 | return 0; | |
78 | ||
79 | fh = to_rmi_function_handler(fn->dev.driver); | |
80 | if (fh->config) { | |
81 | retval = fh->config(fn); | |
82 | if (retval < 0) | |
83 | dev_err(&fn->dev, "Config failed with code %d.\n", | |
84 | retval); | |
85 | } | |
86 | ||
87 | return retval; | |
88 | } | |
89 | ||
90 | static int rmi_driver_process_reset_requests(struct rmi_device *rmi_dev) | |
91 | { | |
92 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
93 | struct rmi_function *entry; | |
94 | int retval; | |
95 | ||
96 | list_for_each_entry(entry, &data->function_list, node) { | |
97 | retval = reset_one_function(entry); | |
98 | if (retval < 0) | |
99 | return retval; | |
100 | } | |
101 | ||
102 | return 0; | |
103 | } | |
104 | ||
105 | static int rmi_driver_process_config_requests(struct rmi_device *rmi_dev) | |
106 | { | |
107 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
108 | struct rmi_function *entry; | |
109 | int retval; | |
110 | ||
111 | list_for_each_entry(entry, &data->function_list, node) { | |
112 | retval = configure_one_function(entry); | |
113 | if (retval < 0) | |
114 | return retval; | |
115 | } | |
116 | ||
117 | return 0; | |
118 | } | |
119 | ||
120 | static void process_one_interrupt(struct rmi_driver_data *data, | |
121 | struct rmi_function *fn) | |
122 | { | |
123 | struct rmi_function_handler *fh; | |
124 | ||
125 | if (!fn || !fn->dev.driver) | |
126 | return; | |
127 | ||
128 | fh = to_rmi_function_handler(fn->dev.driver); | |
a1376d3d | 129 | if (fh->attention) { |
2b6a321d AD |
130 | bitmap_and(data->fn_irq_bits, data->irq_status, fn->irq_mask, |
131 | data->irq_count); | |
132 | if (!bitmap_empty(data->fn_irq_bits, data->irq_count)) | |
133 | fh->attention(fn, data->fn_irq_bits); | |
134 | } | |
135 | } | |
136 | ||
137 | int rmi_process_interrupt_requests(struct rmi_device *rmi_dev) | |
138 | { | |
139 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
140 | struct device *dev = &rmi_dev->dev; | |
141 | struct rmi_function *entry; | |
142 | int error; | |
143 | ||
144 | if (!data) | |
145 | return 0; | |
146 | ||
147 | if (!rmi_dev->xport->attn_data) { | |
148 | error = rmi_read_block(rmi_dev, | |
149 | data->f01_container->fd.data_base_addr + 1, | |
150 | data->irq_status, data->num_of_irq_regs); | |
151 | if (error < 0) { | |
152 | dev_err(dev, "Failed to read irqs, code=%d\n", error); | |
153 | return error; | |
154 | } | |
155 | } | |
156 | ||
157 | mutex_lock(&data->irq_mutex); | |
158 | bitmap_and(data->irq_status, data->irq_status, data->current_irq_mask, | |
159 | data->irq_count); | |
160 | /* | |
161 | * At this point, irq_status has all bits that are set in the | |
162 | * interrupt status register and are enabled. | |
163 | */ | |
164 | mutex_unlock(&data->irq_mutex); | |
165 | ||
166 | /* | |
167 | * It would be nice to be able to use irq_chip to handle these | |
168 | * nested IRQs. Unfortunately, most of the current customers for | |
169 | * this driver are using older kernels (3.0.x) that don't support | |
170 | * the features required for that. Once they've shifted to more | |
171 | * recent kernels (say, 3.3 and higher), this should be switched to | |
172 | * use irq_chip. | |
173 | */ | |
174 | list_for_each_entry(entry, &data->function_list, node) | |
a1376d3d | 175 | process_one_interrupt(data, entry); |
2b6a321d AD |
176 | |
177 | if (data->input) | |
178 | input_sync(data->input); | |
179 | ||
180 | return 0; | |
181 | } | |
182 | EXPORT_SYMBOL_GPL(rmi_process_interrupt_requests); | |
183 | ||
184 | static int suspend_one_function(struct rmi_function *fn) | |
185 | { | |
186 | struct rmi_function_handler *fh; | |
187 | int retval = 0; | |
188 | ||
189 | if (!fn || !fn->dev.driver) | |
190 | return 0; | |
191 | ||
192 | fh = to_rmi_function_handler(fn->dev.driver); | |
193 | if (fh->suspend) { | |
194 | retval = fh->suspend(fn); | |
195 | if (retval < 0) | |
196 | dev_err(&fn->dev, "Suspend failed with code %d.\n", | |
197 | retval); | |
198 | } | |
199 | ||
200 | return retval; | |
201 | } | |
202 | ||
203 | static int rmi_suspend_functions(struct rmi_device *rmi_dev) | |
204 | { | |
205 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
206 | struct rmi_function *entry; | |
207 | int retval; | |
208 | ||
209 | list_for_each_entry(entry, &data->function_list, node) { | |
210 | retval = suspend_one_function(entry); | |
211 | if (retval < 0) | |
212 | return retval; | |
213 | } | |
214 | ||
215 | return 0; | |
216 | } | |
217 | ||
218 | static int resume_one_function(struct rmi_function *fn) | |
219 | { | |
220 | struct rmi_function_handler *fh; | |
221 | int retval = 0; | |
222 | ||
223 | if (!fn || !fn->dev.driver) | |
224 | return 0; | |
225 | ||
226 | fh = to_rmi_function_handler(fn->dev.driver); | |
227 | if (fh->resume) { | |
228 | retval = fh->resume(fn); | |
229 | if (retval < 0) | |
230 | dev_err(&fn->dev, "Resume failed with code %d.\n", | |
231 | retval); | |
232 | } | |
233 | ||
234 | return retval; | |
235 | } | |
236 | ||
237 | static int rmi_resume_functions(struct rmi_device *rmi_dev) | |
238 | { | |
239 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
240 | struct rmi_function *entry; | |
241 | int retval; | |
242 | ||
243 | list_for_each_entry(entry, &data->function_list, node) { | |
244 | retval = resume_one_function(entry); | |
245 | if (retval < 0) | |
246 | return retval; | |
247 | } | |
248 | ||
249 | return 0; | |
250 | } | |
251 | ||
252 | static int enable_sensor(struct rmi_device *rmi_dev) | |
253 | { | |
254 | int retval = 0; | |
255 | ||
256 | retval = rmi_driver_process_config_requests(rmi_dev); | |
257 | if (retval < 0) | |
258 | return retval; | |
259 | ||
260 | return rmi_process_interrupt_requests(rmi_dev); | |
261 | } | |
262 | ||
263 | /** | |
264 | * rmi_driver_set_input_params - set input device id and other data. | |
265 | * | |
266 | * @rmi_dev: Pointer to an RMI device | |
267 | * @input: Pointer to input device | |
268 | * | |
269 | */ | |
270 | static int rmi_driver_set_input_params(struct rmi_device *rmi_dev, | |
271 | struct input_dev *input) | |
272 | { | |
273 | input->name = SYNAPTICS_INPUT_DEVICE_NAME; | |
274 | input->id.vendor = SYNAPTICS_VENDOR_ID; | |
275 | input->id.bustype = BUS_RMI; | |
276 | return 0; | |
277 | } | |
278 | ||
279 | static void rmi_driver_set_input_name(struct rmi_device *rmi_dev, | |
280 | struct input_dev *input) | |
281 | { | |
282 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
283 | char *device_name = rmi_f01_get_product_ID(data->f01_container); | |
284 | char *name; | |
285 | ||
286 | name = devm_kasprintf(&rmi_dev->dev, GFP_KERNEL, | |
287 | "Synaptics %s", device_name); | |
288 | if (!name) | |
289 | return; | |
290 | ||
291 | input->name = name; | |
292 | } | |
293 | ||
294 | static int rmi_driver_set_irq_bits(struct rmi_device *rmi_dev, | |
295 | unsigned long *mask) | |
296 | { | |
297 | int error = 0; | |
298 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
299 | struct device *dev = &rmi_dev->dev; | |
300 | ||
301 | mutex_lock(&data->irq_mutex); | |
302 | bitmap_or(data->new_irq_mask, | |
303 | data->current_irq_mask, mask, data->irq_count); | |
304 | ||
305 | error = rmi_write_block(rmi_dev, | |
306 | data->f01_container->fd.control_base_addr + 1, | |
307 | data->new_irq_mask, data->num_of_irq_regs); | |
308 | if (error < 0) { | |
309 | dev_err(dev, "%s: Failed to change enabled interrupts!", | |
310 | __func__); | |
311 | goto error_unlock; | |
312 | } | |
313 | bitmap_copy(data->current_irq_mask, data->new_irq_mask, | |
314 | data->num_of_irq_regs); | |
315 | ||
316 | error_unlock: | |
317 | mutex_unlock(&data->irq_mutex); | |
318 | return error; | |
319 | } | |
320 | ||
321 | static int rmi_driver_clear_irq_bits(struct rmi_device *rmi_dev, | |
322 | unsigned long *mask) | |
323 | { | |
324 | int error = 0; | |
325 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
326 | struct device *dev = &rmi_dev->dev; | |
327 | ||
328 | mutex_lock(&data->irq_mutex); | |
329 | bitmap_andnot(data->new_irq_mask, | |
330 | data->current_irq_mask, mask, data->irq_count); | |
331 | ||
332 | error = rmi_write_block(rmi_dev, | |
333 | data->f01_container->fd.control_base_addr + 1, | |
334 | data->new_irq_mask, data->num_of_irq_regs); | |
335 | if (error < 0) { | |
336 | dev_err(dev, "%s: Failed to change enabled interrupts!", | |
337 | __func__); | |
338 | goto error_unlock; | |
339 | } | |
340 | bitmap_copy(data->current_irq_mask, data->new_irq_mask, | |
341 | data->num_of_irq_regs); | |
342 | ||
343 | error_unlock: | |
344 | mutex_unlock(&data->irq_mutex); | |
345 | return error; | |
346 | } | |
347 | ||
348 | static int rmi_driver_reset_handler(struct rmi_device *rmi_dev) | |
349 | { | |
350 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
351 | int error; | |
352 | ||
353 | /* | |
354 | * Can get called before the driver is fully ready to deal with | |
355 | * this situation. | |
356 | */ | |
357 | if (!data || !data->f01_container) { | |
358 | dev_warn(&rmi_dev->dev, | |
359 | "Not ready to handle reset yet!\n"); | |
360 | return 0; | |
361 | } | |
362 | ||
363 | error = rmi_read_block(rmi_dev, | |
364 | data->f01_container->fd.control_base_addr + 1, | |
365 | data->current_irq_mask, data->num_of_irq_regs); | |
366 | if (error < 0) { | |
367 | dev_err(&rmi_dev->dev, "%s: Failed to read current IRQ mask.\n", | |
368 | __func__); | |
369 | return error; | |
370 | } | |
371 | ||
372 | error = rmi_driver_process_reset_requests(rmi_dev); | |
373 | if (error < 0) | |
374 | return error; | |
375 | ||
376 | error = rmi_driver_process_config_requests(rmi_dev); | |
377 | if (error < 0) | |
378 | return error; | |
379 | ||
380 | return 0; | |
381 | } | |
382 | ||
383 | int rmi_read_pdt_entry(struct rmi_device *rmi_dev, struct pdt_entry *entry, | |
384 | u16 pdt_address) | |
385 | { | |
386 | u8 buf[RMI_PDT_ENTRY_SIZE]; | |
387 | int error; | |
388 | ||
389 | error = rmi_read_block(rmi_dev, pdt_address, buf, RMI_PDT_ENTRY_SIZE); | |
390 | if (error) { | |
391 | dev_err(&rmi_dev->dev, "Read PDT entry at %#06x failed, code: %d.\n", | |
392 | pdt_address, error); | |
393 | return error; | |
394 | } | |
395 | ||
396 | entry->page_start = pdt_address & RMI4_PAGE_MASK; | |
397 | entry->query_base_addr = buf[0]; | |
398 | entry->command_base_addr = buf[1]; | |
399 | entry->control_base_addr = buf[2]; | |
400 | entry->data_base_addr = buf[3]; | |
401 | entry->interrupt_source_count = buf[4] & RMI_PDT_INT_SOURCE_COUNT_MASK; | |
402 | entry->function_version = (buf[4] & RMI_PDT_FUNCTION_VERSION_MASK) >> 5; | |
403 | entry->function_number = buf[5]; | |
404 | ||
405 | return 0; | |
406 | } | |
407 | EXPORT_SYMBOL_GPL(rmi_read_pdt_entry); | |
408 | ||
409 | static void rmi_driver_copy_pdt_to_fd(const struct pdt_entry *pdt, | |
410 | struct rmi_function_descriptor *fd) | |
411 | { | |
412 | fd->query_base_addr = pdt->query_base_addr + pdt->page_start; | |
413 | fd->command_base_addr = pdt->command_base_addr + pdt->page_start; | |
414 | fd->control_base_addr = pdt->control_base_addr + pdt->page_start; | |
415 | fd->data_base_addr = pdt->data_base_addr + pdt->page_start; | |
416 | fd->function_number = pdt->function_number; | |
417 | fd->interrupt_source_count = pdt->interrupt_source_count; | |
418 | fd->function_version = pdt->function_version; | |
419 | } | |
420 | ||
421 | #define RMI_SCAN_CONTINUE 0 | |
422 | #define RMI_SCAN_DONE 1 | |
423 | ||
424 | static int rmi_scan_pdt_page(struct rmi_device *rmi_dev, | |
425 | int page, | |
426 | void *ctx, | |
427 | int (*callback)(struct rmi_device *rmi_dev, | |
428 | void *ctx, | |
429 | const struct pdt_entry *entry)) | |
430 | { | |
431 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
432 | struct pdt_entry pdt_entry; | |
433 | u16 page_start = RMI4_PAGE_SIZE * page; | |
434 | u16 pdt_start = page_start + PDT_START_SCAN_LOCATION; | |
435 | u16 pdt_end = page_start + PDT_END_SCAN_LOCATION; | |
436 | u16 addr; | |
437 | int error; | |
438 | int retval; | |
439 | ||
440 | for (addr = pdt_start; addr >= pdt_end; addr -= RMI_PDT_ENTRY_SIZE) { | |
441 | error = rmi_read_pdt_entry(rmi_dev, &pdt_entry, addr); | |
442 | if (error) | |
443 | return error; | |
444 | ||
445 | if (RMI4_END_OF_PDT(pdt_entry.function_number)) | |
446 | break; | |
447 | ||
448 | retval = callback(rmi_dev, ctx, &pdt_entry); | |
449 | if (retval != RMI_SCAN_CONTINUE) | |
450 | return retval; | |
451 | } | |
452 | ||
453 | return (data->f01_bootloader_mode || addr == pdt_start) ? | |
454 | RMI_SCAN_DONE : RMI_SCAN_CONTINUE; | |
455 | } | |
456 | ||
457 | static int rmi_scan_pdt(struct rmi_device *rmi_dev, void *ctx, | |
458 | int (*callback)(struct rmi_device *rmi_dev, | |
459 | void *ctx, | |
460 | const struct pdt_entry *entry)) | |
461 | { | |
462 | int page; | |
463 | int retval = RMI_SCAN_DONE; | |
464 | ||
465 | for (page = 0; page <= RMI4_MAX_PAGE; page++) { | |
466 | retval = rmi_scan_pdt_page(rmi_dev, page, ctx, callback); | |
467 | if (retval != RMI_SCAN_CONTINUE) | |
468 | break; | |
469 | } | |
470 | ||
471 | return retval < 0 ? retval : 0; | |
472 | } | |
473 | ||
474 | int rmi_read_register_desc(struct rmi_device *d, u16 addr, | |
475 | struct rmi_register_descriptor *rdesc) | |
476 | { | |
477 | int ret; | |
478 | u8 size_presence_reg; | |
479 | u8 buf[35]; | |
480 | int presense_offset = 1; | |
481 | u8 *struct_buf; | |
482 | int reg; | |
483 | int offset = 0; | |
484 | int map_offset = 0; | |
485 | int i; | |
486 | int b; | |
487 | ||
488 | /* | |
489 | * The first register of the register descriptor is the size of | |
490 | * the register descriptor's presense register. | |
491 | */ | |
492 | ret = rmi_read(d, addr, &size_presence_reg); | |
493 | if (ret) | |
494 | return ret; | |
495 | ++addr; | |
496 | ||
497 | if (size_presence_reg < 0 || size_presence_reg > 35) | |
498 | return -EIO; | |
499 | ||
500 | memset(buf, 0, sizeof(buf)); | |
501 | ||
502 | /* | |
503 | * The presence register contains the size of the register structure | |
504 | * and a bitmap which identified which packet registers are present | |
505 | * for this particular register type (ie query, control, or data). | |
506 | */ | |
507 | ret = rmi_read_block(d, addr, buf, size_presence_reg); | |
508 | if (ret) | |
509 | return ret; | |
510 | ++addr; | |
511 | ||
512 | if (buf[0] == 0) { | |
513 | presense_offset = 3; | |
514 | rdesc->struct_size = buf[1] | (buf[2] << 8); | |
515 | } else { | |
516 | rdesc->struct_size = buf[0]; | |
517 | } | |
518 | ||
519 | for (i = presense_offset; i < size_presence_reg; i++) { | |
520 | for (b = 0; b < 8; b++) { | |
521 | if (buf[i] & (0x1 << b)) | |
522 | bitmap_set(rdesc->presense_map, map_offset, 1); | |
523 | ++map_offset; | |
524 | } | |
525 | } | |
526 | ||
527 | rdesc->num_registers = bitmap_weight(rdesc->presense_map, | |
528 | RMI_REG_DESC_PRESENSE_BITS); | |
529 | ||
530 | rdesc->registers = devm_kzalloc(&d->dev, rdesc->num_registers * | |
531 | sizeof(struct rmi_register_desc_item), | |
532 | GFP_KERNEL); | |
533 | if (!rdesc->registers) | |
534 | return -ENOMEM; | |
535 | ||
536 | /* | |
537 | * Allocate a temporary buffer to hold the register structure. | |
538 | * I'm not using devm_kzalloc here since it will not be retained | |
539 | * after exiting this function | |
540 | */ | |
541 | struct_buf = kzalloc(rdesc->struct_size, GFP_KERNEL); | |
542 | if (!struct_buf) | |
543 | return -ENOMEM; | |
544 | ||
545 | /* | |
546 | * The register structure contains information about every packet | |
547 | * register of this type. This includes the size of the packet | |
548 | * register and a bitmap of all subpackets contained in the packet | |
549 | * register. | |
550 | */ | |
551 | ret = rmi_read_block(d, addr, struct_buf, rdesc->struct_size); | |
552 | if (ret) | |
553 | goto free_struct_buff; | |
554 | ||
555 | reg = find_first_bit(rdesc->presense_map, RMI_REG_DESC_PRESENSE_BITS); | |
556 | map_offset = 0; | |
557 | for (i = 0; i < rdesc->num_registers; i++) { | |
558 | struct rmi_register_desc_item *item = &rdesc->registers[i]; | |
559 | int reg_size = struct_buf[offset]; | |
560 | ||
561 | ++offset; | |
562 | if (reg_size == 0) { | |
563 | reg_size = struct_buf[offset] | | |
564 | (struct_buf[offset + 1] << 8); | |
565 | offset += 2; | |
566 | } | |
567 | ||
568 | if (reg_size == 0) { | |
569 | reg_size = struct_buf[offset] | | |
570 | (struct_buf[offset + 1] << 8) | | |
571 | (struct_buf[offset + 2] << 16) | | |
572 | (struct_buf[offset + 3] << 24); | |
573 | offset += 4; | |
574 | } | |
575 | ||
576 | item->reg = reg; | |
577 | item->reg_size = reg_size; | |
578 | ||
579 | do { | |
580 | for (b = 0; b < 7; b++) { | |
581 | if (struct_buf[offset] & (0x1 << b)) | |
582 | bitmap_set(item->subpacket_map, | |
583 | map_offset, 1); | |
584 | ++map_offset; | |
585 | } | |
586 | } while (struct_buf[offset++] & 0x80); | |
587 | ||
588 | item->num_subpackets = bitmap_weight(item->subpacket_map, | |
589 | RMI_REG_DESC_SUBPACKET_BITS); | |
590 | ||
591 | rmi_dbg(RMI_DEBUG_CORE, &d->dev, | |
592 | "%s: reg: %d reg size: %ld subpackets: %d\n", __func__, | |
593 | item->reg, item->reg_size, item->num_subpackets); | |
594 | ||
595 | reg = find_next_bit(rdesc->presense_map, | |
596 | RMI_REG_DESC_PRESENSE_BITS, reg + 1); | |
597 | } | |
598 | ||
599 | free_struct_buff: | |
600 | kfree(struct_buf); | |
601 | return ret; | |
602 | } | |
603 | EXPORT_SYMBOL_GPL(rmi_read_register_desc); | |
604 | ||
605 | const struct rmi_register_desc_item *rmi_get_register_desc_item( | |
606 | struct rmi_register_descriptor *rdesc, u16 reg) | |
607 | { | |
608 | const struct rmi_register_desc_item *item; | |
609 | int i; | |
610 | ||
611 | for (i = 0; i < rdesc->num_registers; i++) { | |
612 | item = &rdesc->registers[i]; | |
613 | if (item->reg == reg) | |
614 | return item; | |
615 | } | |
616 | ||
617 | return NULL; | |
618 | } | |
619 | EXPORT_SYMBOL_GPL(rmi_get_register_desc_item); | |
620 | ||
621 | size_t rmi_register_desc_calc_size(struct rmi_register_descriptor *rdesc) | |
622 | { | |
623 | const struct rmi_register_desc_item *item; | |
624 | int i; | |
625 | size_t size = 0; | |
626 | ||
627 | for (i = 0; i < rdesc->num_registers; i++) { | |
628 | item = &rdesc->registers[i]; | |
629 | size += item->reg_size; | |
630 | } | |
631 | return size; | |
632 | } | |
633 | EXPORT_SYMBOL_GPL(rmi_register_desc_calc_size); | |
634 | ||
635 | /* Compute the register offset relative to the base address */ | |
636 | int rmi_register_desc_calc_reg_offset( | |
637 | struct rmi_register_descriptor *rdesc, u16 reg) | |
638 | { | |
639 | const struct rmi_register_desc_item *item; | |
640 | int offset = 0; | |
641 | int i; | |
642 | ||
643 | for (i = 0; i < rdesc->num_registers; i++) { | |
644 | item = &rdesc->registers[i]; | |
645 | if (item->reg == reg) | |
646 | return offset; | |
647 | ++offset; | |
648 | } | |
649 | return -1; | |
650 | } | |
651 | EXPORT_SYMBOL_GPL(rmi_register_desc_calc_reg_offset); | |
652 | ||
653 | bool rmi_register_desc_has_subpacket(const struct rmi_register_desc_item *item, | |
654 | u8 subpacket) | |
655 | { | |
656 | return find_next_bit(item->subpacket_map, RMI_REG_DESC_PRESENSE_BITS, | |
657 | subpacket) == subpacket; | |
658 | } | |
659 | ||
660 | /* Indicates that flash programming is enabled (bootloader mode). */ | |
661 | #define RMI_F01_STATUS_BOOTLOADER(status) (!!((status) & 0x40)) | |
662 | ||
663 | /* | |
664 | * Given the PDT entry for F01, read the device status register to determine | |
665 | * if we're stuck in bootloader mode or not. | |
666 | * | |
667 | */ | |
668 | static int rmi_check_bootloader_mode(struct rmi_device *rmi_dev, | |
669 | const struct pdt_entry *pdt) | |
670 | { | |
671 | int error; | |
672 | u8 device_status; | |
673 | ||
674 | error = rmi_read(rmi_dev, pdt->data_base_addr + pdt->page_start, | |
675 | &device_status); | |
676 | if (error) { | |
677 | dev_err(&rmi_dev->dev, | |
678 | "Failed to read device status: %d.\n", error); | |
679 | return error; | |
680 | } | |
681 | ||
682 | return RMI_F01_STATUS_BOOTLOADER(device_status); | |
683 | } | |
684 | ||
685 | static int rmi_count_irqs(struct rmi_device *rmi_dev, | |
686 | void *ctx, const struct pdt_entry *pdt) | |
687 | { | |
688 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
689 | int *irq_count = ctx; | |
690 | ||
691 | *irq_count += pdt->interrupt_source_count; | |
692 | if (pdt->function_number == 0x01) { | |
693 | data->f01_bootloader_mode = | |
694 | rmi_check_bootloader_mode(rmi_dev, pdt); | |
695 | if (data->f01_bootloader_mode) | |
696 | dev_warn(&rmi_dev->dev, | |
697 | "WARNING: RMI4 device is in bootloader mode!\n"); | |
698 | } | |
699 | ||
700 | return RMI_SCAN_CONTINUE; | |
701 | } | |
702 | ||
703 | static int rmi_initial_reset(struct rmi_device *rmi_dev, | |
704 | void *ctx, const struct pdt_entry *pdt) | |
705 | { | |
706 | int error; | |
707 | ||
708 | if (pdt->function_number == 0x01) { | |
709 | u16 cmd_addr = pdt->page_start + pdt->command_base_addr; | |
710 | u8 cmd_buf = RMI_DEVICE_RESET_CMD; | |
711 | const struct rmi_device_platform_data *pdata = | |
712 | rmi_get_platform_data(rmi_dev); | |
713 | ||
714 | if (rmi_dev->xport->ops->reset) { | |
715 | error = rmi_dev->xport->ops->reset(rmi_dev->xport, | |
716 | cmd_addr); | |
717 | if (error) | |
718 | return error; | |
719 | ||
720 | return RMI_SCAN_DONE; | |
721 | } | |
722 | ||
723 | error = rmi_write_block(rmi_dev, cmd_addr, &cmd_buf, 1); | |
724 | if (error) { | |
725 | dev_err(&rmi_dev->dev, | |
726 | "Initial reset failed. Code = %d.\n", error); | |
727 | return error; | |
728 | } | |
729 | ||
730 | mdelay(pdata->reset_delay_ms ?: DEFAULT_RESET_DELAY_MS); | |
731 | ||
732 | return RMI_SCAN_DONE; | |
733 | } | |
734 | ||
735 | /* F01 should always be on page 0. If we don't find it there, fail. */ | |
736 | return pdt->page_start == 0 ? RMI_SCAN_CONTINUE : -ENODEV; | |
737 | } | |
738 | ||
739 | static int rmi_create_function(struct rmi_device *rmi_dev, | |
740 | void *ctx, const struct pdt_entry *pdt) | |
741 | { | |
742 | struct device *dev = &rmi_dev->dev; | |
743 | struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); | |
744 | int *current_irq_count = ctx; | |
745 | struct rmi_function *fn; | |
746 | int i; | |
747 | int error; | |
748 | ||
749 | rmi_dbg(RMI_DEBUG_CORE, dev, "Initializing F%02X.\n", | |
750 | pdt->function_number); | |
751 | ||
752 | fn = kzalloc(sizeof(struct rmi_function) + | |
753 | BITS_TO_LONGS(data->irq_count) * sizeof(unsigned long), | |
754 | GFP_KERNEL); | |
755 | if (!fn) { | |
756 | dev_err(dev, "Failed to allocate memory for F%02X\n", | |
757 | pdt->function_number); | |
758 | return -ENOMEM; | |
759 | } | |
760 | ||
761 | INIT_LIST_HEAD(&fn->node); | |
762 | rmi_driver_copy_pdt_to_fd(pdt, &fn->fd); | |
763 | ||
764 | fn->rmi_dev = rmi_dev; | |
765 | ||
766 | fn->num_of_irqs = pdt->interrupt_source_count; | |
767 | fn->irq_pos = *current_irq_count; | |
768 | *current_irq_count += fn->num_of_irqs; | |
769 | ||
770 | for (i = 0; i < fn->num_of_irqs; i++) | |
771 | set_bit(fn->irq_pos + i, fn->irq_mask); | |
772 | ||
773 | error = rmi_register_function(fn); | |
774 | if (error) | |
775 | goto err_put_fn; | |
776 | ||
777 | if (pdt->function_number == 0x01) | |
778 | data->f01_container = fn; | |
779 | ||
780 | list_add_tail(&fn->node, &data->function_list); | |
781 | ||
782 | return RMI_SCAN_CONTINUE; | |
783 | ||
784 | err_put_fn: | |
785 | put_device(&fn->dev); | |
786 | return error; | |
787 | } | |
788 | ||
789 | int rmi_driver_suspend(struct rmi_device *rmi_dev) | |
790 | { | |
791 | int retval = 0; | |
792 | ||
793 | retval = rmi_suspend_functions(rmi_dev); | |
794 | if (retval) | |
795 | dev_warn(&rmi_dev->dev, "Failed to suspend functions: %d\n", | |
796 | retval); | |
797 | ||
798 | return retval; | |
799 | } | |
800 | EXPORT_SYMBOL_GPL(rmi_driver_suspend); | |
801 | ||
802 | int rmi_driver_resume(struct rmi_device *rmi_dev) | |
803 | { | |
804 | int retval; | |
805 | ||
806 | retval = rmi_resume_functions(rmi_dev); | |
807 | if (retval) | |
808 | dev_warn(&rmi_dev->dev, "Failed to suspend functions: %d\n", | |
809 | retval); | |
810 | ||
811 | return retval; | |
812 | } | |
813 | EXPORT_SYMBOL_GPL(rmi_driver_resume); | |
814 | ||
815 | static int rmi_driver_remove(struct device *dev) | |
816 | { | |
817 | struct rmi_device *rmi_dev = to_rmi_device(dev); | |
818 | ||
819 | rmi_free_function_list(rmi_dev); | |
820 | ||
821 | return 0; | |
822 | } | |
823 | ||
d8a8b3ed AD |
824 | #ifdef CONFIG_OF |
825 | static int rmi_driver_of_probe(struct device *dev, | |
826 | struct rmi_device_platform_data *pdata) | |
827 | { | |
828 | int retval; | |
829 | ||
830 | retval = rmi_of_property_read_u32(dev, &pdata->reset_delay_ms, | |
831 | "syna,reset-delay-ms", 1); | |
832 | if (retval) | |
833 | return retval; | |
834 | ||
835 | return 0; | |
836 | } | |
837 | #else | |
838 | static inline int rmi_driver_of_probe(struct device *dev, | |
839 | struct rmi_device_platform_data *pdata) | |
840 | { | |
841 | return -ENODEV; | |
842 | } | |
843 | #endif | |
844 | ||
2b6a321d AD |
845 | static int rmi_driver_probe(struct device *dev) |
846 | { | |
847 | struct rmi_driver *rmi_driver; | |
848 | struct rmi_driver_data *data; | |
849 | struct rmi_device_platform_data *pdata; | |
850 | struct rmi_device *rmi_dev; | |
851 | size_t size; | |
852 | void *irq_memory; | |
853 | int irq_count; | |
854 | int retval; | |
855 | ||
856 | rmi_dbg(RMI_DEBUG_CORE, dev, "%s: Starting probe.\n", | |
857 | __func__); | |
858 | ||
859 | if (!rmi_is_physical_device(dev)) { | |
860 | rmi_dbg(RMI_DEBUG_CORE, dev, "Not a physical device.\n"); | |
861 | return -ENODEV; | |
862 | } | |
863 | ||
864 | rmi_dev = to_rmi_device(dev); | |
865 | rmi_driver = to_rmi_driver(dev->driver); | |
866 | rmi_dev->driver = rmi_driver; | |
867 | ||
868 | pdata = rmi_get_platform_data(rmi_dev); | |
869 | ||
d8a8b3ed AD |
870 | if (rmi_dev->xport->dev->of_node) { |
871 | retval = rmi_driver_of_probe(rmi_dev->xport->dev, pdata); | |
872 | if (retval) | |
873 | return retval; | |
874 | } | |
875 | ||
2b6a321d AD |
876 | data = devm_kzalloc(dev, sizeof(struct rmi_driver_data), GFP_KERNEL); |
877 | if (!data) | |
878 | return -ENOMEM; | |
879 | ||
880 | INIT_LIST_HEAD(&data->function_list); | |
881 | data->rmi_dev = rmi_dev; | |
882 | dev_set_drvdata(&rmi_dev->dev, data); | |
883 | ||
884 | /* | |
885 | * Right before a warm boot, the sensor might be in some unusual state, | |
886 | * such as F54 diagnostics, or F34 bootloader mode after a firmware | |
887 | * or configuration update. In order to clear the sensor to a known | |
888 | * state and/or apply any updates, we issue a initial reset to clear any | |
889 | * previous settings and force it into normal operation. | |
890 | * | |
891 | * We have to do this before actually building the PDT because | |
892 | * the reflash updates (if any) might cause various registers to move | |
893 | * around. | |
894 | * | |
895 | * For a number of reasons, this initial reset may fail to return | |
896 | * within the specified time, but we'll still be able to bring up the | |
897 | * driver normally after that failure. This occurs most commonly in | |
898 | * a cold boot situation (where then firmware takes longer to come up | |
899 | * than from a warm boot) and the reset_delay_ms in the platform data | |
900 | * has been set too short to accommodate that. Since the sensor will | |
901 | * eventually come up and be usable, we don't want to just fail here | |
902 | * and leave the customer's device unusable. So we warn them, and | |
903 | * continue processing. | |
904 | */ | |
905 | retval = rmi_scan_pdt(rmi_dev, NULL, rmi_initial_reset); | |
906 | if (retval < 0) | |
907 | dev_warn(dev, "RMI initial reset failed! Continuing in spite of this.\n"); | |
908 | ||
909 | retval = rmi_read(rmi_dev, PDT_PROPERTIES_LOCATION, &data->pdt_props); | |
910 | if (retval < 0) { | |
911 | /* | |
912 | * we'll print out a warning and continue since | |
913 | * failure to get the PDT properties is not a cause to fail | |
914 | */ | |
915 | dev_warn(dev, "Could not read PDT properties from %#06x (code %d). Assuming 0x00.\n", | |
916 | PDT_PROPERTIES_LOCATION, retval); | |
917 | } | |
918 | ||
919 | /* | |
920 | * We need to count the IRQs and allocate their storage before scanning | |
921 | * the PDT and creating the function entries, because adding a new | |
922 | * function can trigger events that result in the IRQ related storage | |
923 | * being accessed. | |
924 | */ | |
925 | rmi_dbg(RMI_DEBUG_CORE, dev, "Counting IRQs.\n"); | |
926 | irq_count = 0; | |
927 | retval = rmi_scan_pdt(rmi_dev, &irq_count, rmi_count_irqs); | |
928 | if (retval < 0) { | |
929 | dev_err(dev, "IRQ counting failed with code %d.\n", retval); | |
930 | goto err; | |
931 | } | |
932 | data->irq_count = irq_count; | |
933 | data->num_of_irq_regs = (data->irq_count + 7) / 8; | |
934 | ||
935 | mutex_init(&data->irq_mutex); | |
936 | ||
937 | size = BITS_TO_LONGS(data->irq_count) * sizeof(unsigned long); | |
938 | irq_memory = devm_kzalloc(dev, size * 4, GFP_KERNEL); | |
939 | if (!irq_memory) { | |
940 | dev_err(dev, "Failed to allocate memory for irq masks.\n"); | |
941 | goto err; | |
942 | } | |
943 | ||
944 | data->irq_status = irq_memory + size * 0; | |
945 | data->fn_irq_bits = irq_memory + size * 1; | |
946 | data->current_irq_mask = irq_memory + size * 2; | |
947 | data->new_irq_mask = irq_memory + size * 3; | |
948 | ||
949 | if (rmi_dev->xport->input) { | |
950 | /* | |
951 | * The transport driver already has an input device. | |
952 | * In some cases it is preferable to reuse the transport | |
953 | * devices input device instead of creating a new one here. | |
954 | * One example is some HID touchpads report "pass-through" | |
955 | * button events are not reported by rmi registers. | |
956 | */ | |
957 | data->input = rmi_dev->xport->input; | |
958 | } else { | |
959 | data->input = devm_input_allocate_device(dev); | |
960 | if (!data->input) { | |
961 | dev_err(dev, "%s: Failed to allocate input device.\n", | |
962 | __func__); | |
963 | retval = -ENOMEM; | |
964 | goto err_destroy_functions; | |
965 | } | |
966 | rmi_driver_set_input_params(rmi_dev, data->input); | |
967 | data->input->phys = devm_kasprintf(dev, GFP_KERNEL, | |
968 | "%s/input0", dev_name(dev)); | |
969 | } | |
970 | ||
971 | irq_count = 0; | |
972 | rmi_dbg(RMI_DEBUG_CORE, dev, "Creating functions."); | |
973 | retval = rmi_scan_pdt(rmi_dev, &irq_count, rmi_create_function); | |
974 | if (retval < 0) { | |
975 | dev_err(dev, "Function creation failed with code %d.\n", | |
976 | retval); | |
977 | goto err_destroy_functions; | |
978 | } | |
979 | ||
980 | if (!data->f01_container) { | |
981 | dev_err(dev, "Missing F01 container!\n"); | |
982 | retval = -EINVAL; | |
983 | goto err_destroy_functions; | |
984 | } | |
985 | ||
986 | retval = rmi_read_block(rmi_dev, | |
987 | data->f01_container->fd.control_base_addr + 1, | |
988 | data->current_irq_mask, data->num_of_irq_regs); | |
989 | if (retval < 0) { | |
990 | dev_err(dev, "%s: Failed to read current IRQ mask.\n", | |
991 | __func__); | |
992 | goto err_destroy_functions; | |
993 | } | |
994 | ||
995 | if (data->input) { | |
996 | rmi_driver_set_input_name(rmi_dev, data->input); | |
997 | if (!rmi_dev->xport->input) { | |
998 | if (input_register_device(data->input)) { | |
999 | dev_err(dev, "%s: Failed to register input device.\n", | |
1000 | __func__); | |
1001 | goto err_destroy_functions; | |
1002 | } | |
1003 | } | |
1004 | } | |
1005 | ||
1006 | if (data->f01_container->dev.driver) | |
1007 | /* Driver already bound, so enable ATTN now. */ | |
1008 | return enable_sensor(rmi_dev); | |
1009 | ||
1010 | return 0; | |
1011 | ||
1012 | err_destroy_functions: | |
1013 | rmi_free_function_list(rmi_dev); | |
1014 | err: | |
1015 | return retval < 0 ? retval : 0; | |
1016 | } | |
1017 | ||
1018 | static struct rmi_driver rmi_physical_driver = { | |
1019 | .driver = { | |
1020 | .owner = THIS_MODULE, | |
1021 | .name = "rmi4_physical", | |
1022 | .bus = &rmi_bus_type, | |
1023 | .probe = rmi_driver_probe, | |
1024 | .remove = rmi_driver_remove, | |
1025 | }, | |
1026 | .reset_handler = rmi_driver_reset_handler, | |
1027 | .clear_irq_bits = rmi_driver_clear_irq_bits, | |
1028 | .set_irq_bits = rmi_driver_set_irq_bits, | |
1029 | .set_input_params = rmi_driver_set_input_params, | |
1030 | }; | |
1031 | ||
1032 | bool rmi_is_physical_driver(struct device_driver *drv) | |
1033 | { | |
1034 | return drv == &rmi_physical_driver.driver; | |
1035 | } | |
1036 | ||
1037 | int __init rmi_register_physical_driver(void) | |
1038 | { | |
1039 | int error; | |
1040 | ||
1041 | error = driver_register(&rmi_physical_driver.driver); | |
1042 | if (error) { | |
1043 | pr_err("%s: driver register failed, code=%d.\n", __func__, | |
1044 | error); | |
1045 | return error; | |
1046 | } | |
1047 | ||
1048 | return 0; | |
1049 | } | |
1050 | ||
1051 | void __exit rmi_unregister_physical_driver(void) | |
1052 | { | |
1053 | driver_unregister(&rmi_physical_driver.driver); | |
1054 | } |