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/pm.h> 21 #include <linux/slab.h> 22 #include <linux/of.h> 23 #include <uapi/linux/input.h> 24 #include <linux/rmi.h> 25 #include "rmi_bus.h" 26 #include "rmi_driver.h" 27 28 #define HAS_NONSTANDARD_PDT_MASK 0x40 29 #define RMI4_MAX_PAGE 0xff 30 #define RMI4_PAGE_SIZE 0x100 31 #define RMI4_PAGE_MASK 0xFF00 32 33 #define RMI_DEVICE_RESET_CMD 0x01 34 #define DEFAULT_RESET_DELAY_MS 100 35 36 static void rmi_free_function_list(struct rmi_device *rmi_dev) 37 { 38 struct rmi_function *fn, *tmp; 39 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); 40 41 data->f01_container = NULL; 42 43 /* Doing it in the reverse order so F01 will be removed last */ 44 list_for_each_entry_safe_reverse(fn, tmp, 45 &data->function_list, node) { 46 list_del(&fn->node); 47 rmi_unregister_function(fn); 48 } 49 } 50 51 static int reset_one_function(struct rmi_function *fn) 52 { 53 struct rmi_function_handler *fh; 54 int retval = 0; 55 56 if (!fn || !fn->dev.driver) 57 return 0; 58 59 fh = to_rmi_function_handler(fn->dev.driver); 60 if (fh->reset) { 61 retval = fh->reset(fn); 62 if (retval < 0) 63 dev_err(&fn->dev, "Reset failed with code %d.\n", 64 retval); 65 } 66 67 return retval; 68 } 69 70 static int configure_one_function(struct rmi_function *fn) 71 { 72 struct rmi_function_handler *fh; 73 int retval = 0; 74 75 if (!fn || !fn->dev.driver) 76 return 0; 77 78 fh = to_rmi_function_handler(fn->dev.driver); 79 if (fh->config) { 80 retval = fh->config(fn); 81 if (retval < 0) 82 dev_err(&fn->dev, "Config failed with code %d.\n", 83 retval); 84 } 85 86 return retval; 87 } 88 89 static int rmi_driver_process_reset_requests(struct rmi_device *rmi_dev) 90 { 91 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); 92 struct rmi_function *entry; 93 int retval; 94 95 list_for_each_entry(entry, &data->function_list, node) { 96 retval = reset_one_function(entry); 97 if (retval < 0) 98 return retval; 99 } 100 101 return 0; 102 } 103 104 static int rmi_driver_process_config_requests(struct rmi_device *rmi_dev) 105 { 106 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); 107 struct rmi_function *entry; 108 int retval; 109 110 list_for_each_entry(entry, &data->function_list, node) { 111 retval = configure_one_function(entry); 112 if (retval < 0) 113 return retval; 114 } 115 116 return 0; 117 } 118 119 static void process_one_interrupt(struct rmi_driver_data *data, 120 struct rmi_function *fn) 121 { 122 struct rmi_function_handler *fh; 123 124 if (!fn || !fn->dev.driver) 125 return; 126 127 fh = to_rmi_function_handler(fn->dev.driver); 128 if (fh->attention) { 129 bitmap_and(data->fn_irq_bits, data->irq_status, fn->irq_mask, 130 data->irq_count); 131 if (!bitmap_empty(data->fn_irq_bits, data->irq_count)) 132 fh->attention(fn, data->fn_irq_bits); 133 } 134 } 135 136 int rmi_process_interrupt_requests(struct rmi_device *rmi_dev) 137 { 138 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); 139 struct device *dev = &rmi_dev->dev; 140 struct rmi_function *entry; 141 int error; 142 143 if (!data) 144 return 0; 145 146 if (!rmi_dev->xport->attn_data) { 147 error = rmi_read_block(rmi_dev, 148 data->f01_container->fd.data_base_addr + 1, 149 data->irq_status, data->num_of_irq_regs); 150 if (error < 0) { 151 dev_err(dev, "Failed to read irqs, code=%d\n", error); 152 return error; 153 } 154 } 155 156 mutex_lock(&data->irq_mutex); 157 bitmap_and(data->irq_status, data->irq_status, data->current_irq_mask, 158 data->irq_count); 159 /* 160 * At this point, irq_status has all bits that are set in the 161 * interrupt status register and are enabled. 162 */ 163 mutex_unlock(&data->irq_mutex); 164 165 /* 166 * It would be nice to be able to use irq_chip to handle these 167 * nested IRQs. Unfortunately, most of the current customers for 168 * this driver are using older kernels (3.0.x) that don't support 169 * the features required for that. Once they've shifted to more 170 * recent kernels (say, 3.3 and higher), this should be switched to 171 * use irq_chip. 172 */ 173 list_for_each_entry(entry, &data->function_list, node) 174 process_one_interrupt(data, entry); 175 176 if (data->input) 177 input_sync(data->input); 178 179 return 0; 180 } 181 EXPORT_SYMBOL_GPL(rmi_process_interrupt_requests); 182 183 static int suspend_one_function(struct rmi_function *fn) 184 { 185 struct rmi_function_handler *fh; 186 int retval = 0; 187 188 if (!fn || !fn->dev.driver) 189 return 0; 190 191 fh = to_rmi_function_handler(fn->dev.driver); 192 if (fh->suspend) { 193 retval = fh->suspend(fn); 194 if (retval < 0) 195 dev_err(&fn->dev, "Suspend failed with code %d.\n", 196 retval); 197 } 198 199 return retval; 200 } 201 202 static int rmi_suspend_functions(struct rmi_device *rmi_dev) 203 { 204 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); 205 struct rmi_function *entry; 206 int retval; 207 208 list_for_each_entry(entry, &data->function_list, node) { 209 retval = suspend_one_function(entry); 210 if (retval < 0) 211 return retval; 212 } 213 214 return 0; 215 } 216 217 static int resume_one_function(struct rmi_function *fn) 218 { 219 struct rmi_function_handler *fh; 220 int retval = 0; 221 222 if (!fn || !fn->dev.driver) 223 return 0; 224 225 fh = to_rmi_function_handler(fn->dev.driver); 226 if (fh->resume) { 227 retval = fh->resume(fn); 228 if (retval < 0) 229 dev_err(&fn->dev, "Resume failed with code %d.\n", 230 retval); 231 } 232 233 return retval; 234 } 235 236 static int rmi_resume_functions(struct rmi_device *rmi_dev) 237 { 238 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); 239 struct rmi_function *entry; 240 int retval; 241 242 list_for_each_entry(entry, &data->function_list, node) { 243 retval = resume_one_function(entry); 244 if (retval < 0) 245 return retval; 246 } 247 248 return 0; 249 } 250 251 static int enable_sensor(struct rmi_device *rmi_dev) 252 { 253 int retval = 0; 254 255 retval = rmi_driver_process_config_requests(rmi_dev); 256 if (retval < 0) 257 return retval; 258 259 return rmi_process_interrupt_requests(rmi_dev); 260 } 261 262 /** 263 * rmi_driver_set_input_params - set input device id and other data. 264 * 265 * @rmi_dev: Pointer to an RMI device 266 * @input: Pointer to input device 267 * 268 */ 269 static int rmi_driver_set_input_params(struct rmi_device *rmi_dev, 270 struct input_dev *input) 271 { 272 input->name = SYNAPTICS_INPUT_DEVICE_NAME; 273 input->id.vendor = SYNAPTICS_VENDOR_ID; 274 input->id.bustype = BUS_RMI; 275 return 0; 276 } 277 278 static void rmi_driver_set_input_name(struct rmi_device *rmi_dev, 279 struct input_dev *input) 280 { 281 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); 282 char *device_name = rmi_f01_get_product_ID(data->f01_container); 283 char *name; 284 285 name = devm_kasprintf(&rmi_dev->dev, GFP_KERNEL, 286 "Synaptics %s", device_name); 287 if (!name) 288 return; 289 290 input->name = name; 291 } 292 293 static int rmi_driver_set_irq_bits(struct rmi_device *rmi_dev, 294 unsigned long *mask) 295 { 296 int error = 0; 297 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); 298 struct device *dev = &rmi_dev->dev; 299 300 mutex_lock(&data->irq_mutex); 301 bitmap_or(data->new_irq_mask, 302 data->current_irq_mask, mask, data->irq_count); 303 304 error = rmi_write_block(rmi_dev, 305 data->f01_container->fd.control_base_addr + 1, 306 data->new_irq_mask, data->num_of_irq_regs); 307 if (error < 0) { 308 dev_err(dev, "%s: Failed to change enabled interrupts!", 309 __func__); 310 goto error_unlock; 311 } 312 bitmap_copy(data->current_irq_mask, data->new_irq_mask, 313 data->num_of_irq_regs); 314 315 error_unlock: 316 mutex_unlock(&data->irq_mutex); 317 return error; 318 } 319 320 static int rmi_driver_clear_irq_bits(struct rmi_device *rmi_dev, 321 unsigned long *mask) 322 { 323 int error = 0; 324 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); 325 struct device *dev = &rmi_dev->dev; 326 327 mutex_lock(&data->irq_mutex); 328 bitmap_andnot(data->new_irq_mask, 329 data->current_irq_mask, mask, data->irq_count); 330 331 error = rmi_write_block(rmi_dev, 332 data->f01_container->fd.control_base_addr + 1, 333 data->new_irq_mask, data->num_of_irq_regs); 334 if (error < 0) { 335 dev_err(dev, "%s: Failed to change enabled interrupts!", 336 __func__); 337 goto error_unlock; 338 } 339 bitmap_copy(data->current_irq_mask, data->new_irq_mask, 340 data->num_of_irq_regs); 341 342 error_unlock: 343 mutex_unlock(&data->irq_mutex); 344 return error; 345 } 346 347 static int rmi_driver_reset_handler(struct rmi_device *rmi_dev) 348 { 349 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); 350 int error; 351 352 /* 353 * Can get called before the driver is fully ready to deal with 354 * this situation. 355 */ 356 if (!data || !data->f01_container) { 357 dev_warn(&rmi_dev->dev, 358 "Not ready to handle reset yet!\n"); 359 return 0; 360 } 361 362 error = rmi_read_block(rmi_dev, 363 data->f01_container->fd.control_base_addr + 1, 364 data->current_irq_mask, data->num_of_irq_regs); 365 if (error < 0) { 366 dev_err(&rmi_dev->dev, "%s: Failed to read current IRQ mask.\n", 367 __func__); 368 return error; 369 } 370 371 error = rmi_driver_process_reset_requests(rmi_dev); 372 if (error < 0) 373 return error; 374 375 error = rmi_driver_process_config_requests(rmi_dev); 376 if (error < 0) 377 return error; 378 379 return 0; 380 } 381 382 int rmi_read_pdt_entry(struct rmi_device *rmi_dev, struct pdt_entry *entry, 383 u16 pdt_address) 384 { 385 u8 buf[RMI_PDT_ENTRY_SIZE]; 386 int error; 387 388 error = rmi_read_block(rmi_dev, pdt_address, buf, RMI_PDT_ENTRY_SIZE); 389 if (error) { 390 dev_err(&rmi_dev->dev, "Read PDT entry at %#06x failed, code: %d.\n", 391 pdt_address, error); 392 return error; 393 } 394 395 entry->page_start = pdt_address & RMI4_PAGE_MASK; 396 entry->query_base_addr = buf[0]; 397 entry->command_base_addr = buf[1]; 398 entry->control_base_addr = buf[2]; 399 entry->data_base_addr = buf[3]; 400 entry->interrupt_source_count = buf[4] & RMI_PDT_INT_SOURCE_COUNT_MASK; 401 entry->function_version = (buf[4] & RMI_PDT_FUNCTION_VERSION_MASK) >> 5; 402 entry->function_number = buf[5]; 403 404 return 0; 405 } 406 EXPORT_SYMBOL_GPL(rmi_read_pdt_entry); 407 408 static void rmi_driver_copy_pdt_to_fd(const struct pdt_entry *pdt, 409 struct rmi_function_descriptor *fd) 410 { 411 fd->query_base_addr = pdt->query_base_addr + pdt->page_start; 412 fd->command_base_addr = pdt->command_base_addr + pdt->page_start; 413 fd->control_base_addr = pdt->control_base_addr + pdt->page_start; 414 fd->data_base_addr = pdt->data_base_addr + pdt->page_start; 415 fd->function_number = pdt->function_number; 416 fd->interrupt_source_count = pdt->interrupt_source_count; 417 fd->function_version = pdt->function_version; 418 } 419 420 #define RMI_SCAN_CONTINUE 0 421 #define RMI_SCAN_DONE 1 422 423 static int rmi_scan_pdt_page(struct rmi_device *rmi_dev, 424 int page, 425 void *ctx, 426 int (*callback)(struct rmi_device *rmi_dev, 427 void *ctx, 428 const struct pdt_entry *entry)) 429 { 430 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev); 431 struct pdt_entry pdt_entry; 432 u16 page_start = RMI4_PAGE_SIZE * page; 433 u16 pdt_start = page_start + PDT_START_SCAN_LOCATION; 434 u16 pdt_end = page_start + PDT_END_SCAN_LOCATION; 435 u16 addr; 436 int error; 437 int retval; 438 439 for (addr = pdt_start; addr >= pdt_end; addr -= RMI_PDT_ENTRY_SIZE) { 440 error = rmi_read_pdt_entry(rmi_dev, &pdt_entry, addr); 441 if (error) 442 return error; 443 444 if (RMI4_END_OF_PDT(pdt_entry.function_number)) 445 break; 446 447 retval = callback(rmi_dev, ctx, &pdt_entry); 448 if (retval != RMI_SCAN_CONTINUE) 449 return retval; 450 } 451 452 return (data->f01_bootloader_mode || addr == pdt_start) ? 453 RMI_SCAN_DONE : RMI_SCAN_CONTINUE; 454 } 455 456 static int rmi_scan_pdt(struct rmi_device *rmi_dev, void *ctx, 457 int (*callback)(struct rmi_device *rmi_dev, 458 void *ctx, 459 const struct pdt_entry *entry)) 460 { 461 int page; 462 int retval = RMI_SCAN_DONE; 463 464 for (page = 0; page <= RMI4_MAX_PAGE; page++) { 465 retval = rmi_scan_pdt_page(rmi_dev, page, ctx, callback); 466 if (retval != RMI_SCAN_CONTINUE) 467 break; 468 } 469 470 return retval < 0 ? retval : 0; 471 } 472 473 int rmi_read_register_desc(struct rmi_device *d, u16 addr, 474 struct rmi_register_descriptor *rdesc) 475 { 476 int ret; 477 u8 size_presence_reg; 478 u8 buf[35]; 479 int presense_offset = 1; 480 u8 *struct_buf; 481 int reg; 482 int offset = 0; 483 int map_offset = 0; 484 int i; 485 int b; 486 487 /* 488 * The first register of the register descriptor is the size of 489 * the register descriptor's presense register. 490 */ 491 ret = rmi_read(d, addr, &size_presence_reg); 492 if (ret) 493 return ret; 494 ++addr; 495 496 if (size_presence_reg < 0 || size_presence_reg > 35) 497 return -EIO; 498 499 memset(buf, 0, sizeof(buf)); 500 501 /* 502 * The presence register contains the size of the register structure 503 * and a bitmap which identified which packet registers are present 504 * for this particular register type (ie query, control, or data). 505 */ 506 ret = rmi_read_block(d, addr, buf, size_presence_reg); 507 if (ret) 508 return ret; 509 ++addr; 510 511 if (buf[0] == 0) { 512 presense_offset = 3; 513 rdesc->struct_size = buf[1] | (buf[2] << 8); 514 } else { 515 rdesc->struct_size = buf[0]; 516 } 517 518 for (i = presense_offset; i < size_presence_reg; i++) { 519 for (b = 0; b < 8; b++) { 520 if (buf[i] & (0x1 << b)) 521 bitmap_set(rdesc->presense_map, map_offset, 1); 522 ++map_offset; 523 } 524 } 525 526 rdesc->num_registers = bitmap_weight(rdesc->presense_map, 527 RMI_REG_DESC_PRESENSE_BITS); 528 529 rdesc->registers = devm_kzalloc(&d->dev, rdesc->num_registers * 530 sizeof(struct rmi_register_desc_item), 531 GFP_KERNEL); 532 if (!rdesc->registers) 533 return -ENOMEM; 534 535 /* 536 * Allocate a temporary buffer to hold the register structure. 537 * I'm not using devm_kzalloc here since it will not be retained 538 * after exiting this function 539 */ 540 struct_buf = kzalloc(rdesc->struct_size, GFP_KERNEL); 541 if (!struct_buf) 542 return -ENOMEM; 543 544 /* 545 * The register structure contains information about every packet 546 * register of this type. This includes the size of the packet 547 * register and a bitmap of all subpackets contained in the packet 548 * register. 549 */ 550 ret = rmi_read_block(d, addr, struct_buf, rdesc->struct_size); 551 if (ret) 552 goto free_struct_buff; 553 554 reg = find_first_bit(rdesc->presense_map, RMI_REG_DESC_PRESENSE_BITS); 555 for (i = 0; i < rdesc->num_registers; i++) { 556 struct rmi_register_desc_item *item = &rdesc->registers[i]; 557 int reg_size = struct_buf[offset]; 558 559 ++offset; 560 if (reg_size == 0) { 561 reg_size = struct_buf[offset] | 562 (struct_buf[offset + 1] << 8); 563 offset += 2; 564 } 565 566 if (reg_size == 0) { 567 reg_size = struct_buf[offset] | 568 (struct_buf[offset + 1] << 8) | 569 (struct_buf[offset + 2] << 16) | 570 (struct_buf[offset + 3] << 24); 571 offset += 4; 572 } 573 574 item->reg = reg; 575 item->reg_size = reg_size; 576 577 map_offset = 0; 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 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 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 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 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 } 1055