1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright (c) 2011-2016 Synaptics Incorporated 4 * Copyright (c) 2011 Unixphere 5 */ 6 7#include <linux/kernel.h> 8#include <linux/rmi.h> 9#include <linux/slab.h> 10#include <linux/uaccess.h> 11#include <linux/of.h> 12#include <asm/unaligned.h> 13#include "rmi_driver.h" 14 15#define RMI_PRODUCT_ID_LENGTH 10 16#define RMI_PRODUCT_INFO_LENGTH 2 17 18#define RMI_DATE_CODE_LENGTH 3 19 20#define PRODUCT_ID_OFFSET 0x10 21#define PRODUCT_INFO_OFFSET 0x1E 22 23 24/* Force a firmware reset of the sensor */ 25#define RMI_F01_CMD_DEVICE_RESET 1 26 27/* Various F01_RMI_QueryX bits */ 28 29#define RMI_F01_QRY1_CUSTOM_MAP BIT(0) 30#define RMI_F01_QRY1_NON_COMPLIANT BIT(1) 31#define RMI_F01_QRY1_HAS_LTS BIT(2) 32#define RMI_F01_QRY1_HAS_SENSOR_ID BIT(3) 33#define RMI_F01_QRY1_HAS_CHARGER_INP BIT(4) 34#define RMI_F01_QRY1_HAS_ADJ_DOZE BIT(5) 35#define RMI_F01_QRY1_HAS_ADJ_DOZE_HOFF BIT(6) 36#define RMI_F01_QRY1_HAS_QUERY42 BIT(7) 37 38#define RMI_F01_QRY5_YEAR_MASK 0x1f 39#define RMI_F01_QRY6_MONTH_MASK 0x0f 40#define RMI_F01_QRY7_DAY_MASK 0x1f 41 42#define RMI_F01_QRY2_PRODINFO_MASK 0x7f 43 44#define RMI_F01_BASIC_QUERY_LEN 21 /* From Query 00 through 20 */ 45 46struct f01_basic_properties { 47 u8 manufacturer_id; 48 bool has_lts; 49 bool has_adjustable_doze; 50 bool has_adjustable_doze_holdoff; 51 char dom[11]; /* YYYY/MM/DD + '\0' */ 52 u8 product_id[RMI_PRODUCT_ID_LENGTH + 1]; 53 u16 productinfo; 54 u32 firmware_id; 55 u32 package_id; 56}; 57 58/* F01 device status bits */ 59 60/* Most recent device status event */ 61#define RMI_F01_STATUS_CODE(status) ((status) & 0x0f) 62/* The device has lost its configuration for some reason. */ 63#define RMI_F01_STATUS_UNCONFIGURED(status) (!!((status) & 0x80)) 64/* The device is in bootloader mode */ 65#define RMI_F01_STATUS_BOOTLOADER(status) ((status) & 0x40) 66 67/* Control register bits */ 68 69/* 70 * Sleep mode controls power management on the device and affects all 71 * functions of the device. 72 */ 73#define RMI_F01_CTRL0_SLEEP_MODE_MASK 0x03 74 75#define RMI_SLEEP_MODE_NORMAL 0x00 76#define RMI_SLEEP_MODE_SENSOR_SLEEP 0x01 77#define RMI_SLEEP_MODE_RESERVED0 0x02 78#define RMI_SLEEP_MODE_RESERVED1 0x03 79 80/* 81 * This bit disables whatever sleep mode may be selected by the sleep_mode 82 * field and forces the device to run at full power without sleeping. 83 */ 84#define RMI_F01_CTRL0_NOSLEEP_BIT BIT(2) 85 86/* 87 * When this bit is set, the touch controller employs a noise-filtering 88 * algorithm designed for use with a connected battery charger. 89 */ 90#define RMI_F01_CTRL0_CHARGER_BIT BIT(5) 91 92/* 93 * Sets the report rate for the device. The effect of this setting is 94 * highly product dependent. Check the spec sheet for your particular 95 * touch sensor. 96 */ 97#define RMI_F01_CTRL0_REPORTRATE_BIT BIT(6) 98 99/* 100 * Written by the host as an indicator that the device has been 101 * successfully configured. 102 */ 103#define RMI_F01_CTRL0_CONFIGURED_BIT BIT(7) 104 105/** 106 * struct f01_device_control - controls basic sensor functions 107 * 108 * @ctrl0: see the bit definitions above. 109 * @doze_interval: controls the interval between checks for finger presence 110 * when the touch sensor is in doze mode, in units of 10ms. 111 * @wakeup_threshold: controls the capacitance threshold at which the touch 112 * sensor will decide to wake up from that low power state. 113 * @doze_holdoff: controls how long the touch sensor waits after the last 114 * finger lifts before entering the doze state, in units of 100ms. 115 */ 116struct f01_device_control { 117 u8 ctrl0; 118 u8 doze_interval; 119 u8 wakeup_threshold; 120 u8 doze_holdoff; 121}; 122 123struct f01_data { 124 struct f01_basic_properties properties; 125 struct f01_device_control device_control; 126 127 u16 doze_interval_addr; 128 u16 wakeup_threshold_addr; 129 u16 doze_holdoff_addr; 130 131 bool suspended; 132 bool old_nosleep; 133 134 unsigned int num_of_irq_regs; 135}; 136 137static int rmi_f01_read_properties(struct rmi_device *rmi_dev, 138 u16 query_base_addr, 139 struct f01_basic_properties *props) 140{ 141 u8 queries[RMI_F01_BASIC_QUERY_LEN]; 142 int ret; 143 int query_offset = query_base_addr; 144 bool has_ds4_queries = false; 145 bool has_query42 = false; 146 bool has_sensor_id = false; 147 bool has_package_id_query = false; 148 bool has_build_id_query = false; 149 u16 prod_info_addr; 150 u8 ds4_query_len; 151 152 ret = rmi_read_block(rmi_dev, query_offset, 153 queries, RMI_F01_BASIC_QUERY_LEN); 154 if (ret) { 155 dev_err(&rmi_dev->dev, 156 "Failed to read device query registers: %d\n", ret); 157 return ret; 158 } 159 160 prod_info_addr = query_offset + 17; 161 query_offset += RMI_F01_BASIC_QUERY_LEN; 162 163 /* Now parse what we got */ 164 props->manufacturer_id = queries[0]; 165 166 props->has_lts = queries[1] & RMI_F01_QRY1_HAS_LTS; 167 props->has_adjustable_doze = 168 queries[1] & RMI_F01_QRY1_HAS_ADJ_DOZE; 169 props->has_adjustable_doze_holdoff = 170 queries[1] & RMI_F01_QRY1_HAS_ADJ_DOZE_HOFF; 171 has_query42 = queries[1] & RMI_F01_QRY1_HAS_QUERY42; 172 has_sensor_id = queries[1] & RMI_F01_QRY1_HAS_SENSOR_ID; 173 174 snprintf(props->dom, sizeof(props->dom), "20%02d/%02d/%02d", 175 queries[5] & RMI_F01_QRY5_YEAR_MASK, 176 queries[6] & RMI_F01_QRY6_MONTH_MASK, 177 queries[7] & RMI_F01_QRY7_DAY_MASK); 178 179 memcpy(props->product_id, &queries[11], 180 RMI_PRODUCT_ID_LENGTH); 181 props->product_id[RMI_PRODUCT_ID_LENGTH] = '\0'; 182 183 props->productinfo = 184 ((queries[2] & RMI_F01_QRY2_PRODINFO_MASK) << 7) | 185 (queries[3] & RMI_F01_QRY2_PRODINFO_MASK); 186 187 if (has_sensor_id) 188 query_offset++; 189 190 if (has_query42) { 191 ret = rmi_read(rmi_dev, query_offset, queries); 192 if (ret) { 193 dev_err(&rmi_dev->dev, 194 "Failed to read query 42 register: %d\n", ret); 195 return ret; 196 } 197 198 has_ds4_queries = !!(queries[0] & BIT(0)); 199 query_offset++; 200 } 201 202 if (has_ds4_queries) { 203 ret = rmi_read(rmi_dev, query_offset, &ds4_query_len); 204 if (ret) { 205 dev_err(&rmi_dev->dev, 206 "Failed to read DS4 queries length: %d\n", ret); 207 return ret; 208 } 209 query_offset++; 210 211 if (ds4_query_len > 0) { 212 ret = rmi_read(rmi_dev, query_offset, queries); 213 if (ret) { 214 dev_err(&rmi_dev->dev, 215 "Failed to read DS4 queries: %d\n", 216 ret); 217 return ret; 218 } 219 220 has_package_id_query = !!(queries[0] & BIT(0)); 221 has_build_id_query = !!(queries[0] & BIT(1)); 222 } 223 224 if (has_package_id_query) { 225 ret = rmi_read_block(rmi_dev, prod_info_addr, 226 queries, sizeof(__le64)); 227 if (ret) { 228 dev_err(&rmi_dev->dev, 229 "Failed to read package info: %d\n", 230 ret); 231 return ret; 232 } 233 234 props->package_id = get_unaligned_le64(queries); 235 prod_info_addr++; 236 } 237 238 if (has_build_id_query) { 239 ret = rmi_read_block(rmi_dev, prod_info_addr, queries, 240 3); 241 if (ret) { 242 dev_err(&rmi_dev->dev, 243 "Failed to read product info: %d\n", 244 ret); 245 return ret; 246 } 247 248 props->firmware_id = queries[1] << 8 | queries[0]; 249 props->firmware_id += queries[2] * 65536; 250 } 251 } 252 253 return 0; 254} 255 256const char *rmi_f01_get_product_ID(struct rmi_function *fn) 257{ 258 struct f01_data *f01 = dev_get_drvdata(&fn->dev); 259 260 return f01->properties.product_id; 261} 262 263static ssize_t rmi_driver_manufacturer_id_show(struct device *dev, 264 struct device_attribute *dattr, 265 char *buf) 266{ 267 struct rmi_driver_data *data = dev_get_drvdata(dev); 268 struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev); 269 270 return scnprintf(buf, PAGE_SIZE, "%d\n", 271 f01->properties.manufacturer_id); 272} 273 274static DEVICE_ATTR(manufacturer_id, 0444, 275 rmi_driver_manufacturer_id_show, NULL); 276 277static ssize_t rmi_driver_dom_show(struct device *dev, 278 struct device_attribute *dattr, char *buf) 279{ 280 struct rmi_driver_data *data = dev_get_drvdata(dev); 281 struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev); 282 283 return scnprintf(buf, PAGE_SIZE, "%s\n", f01->properties.dom); 284} 285 286static DEVICE_ATTR(date_of_manufacture, 0444, rmi_driver_dom_show, NULL); 287 288static ssize_t rmi_driver_product_id_show(struct device *dev, 289 struct device_attribute *dattr, 290 char *buf) 291{ 292 struct rmi_driver_data *data = dev_get_drvdata(dev); 293 struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev); 294 295 return scnprintf(buf, PAGE_SIZE, "%s\n", f01->properties.product_id); 296} 297 298static DEVICE_ATTR(product_id, 0444, rmi_driver_product_id_show, NULL); 299 300static ssize_t rmi_driver_firmware_id_show(struct device *dev, 301 struct device_attribute *dattr, 302 char *buf) 303{ 304 struct rmi_driver_data *data = dev_get_drvdata(dev); 305 struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev); 306 307 return scnprintf(buf, PAGE_SIZE, "%d\n", f01->properties.firmware_id); 308} 309 310static DEVICE_ATTR(firmware_id, 0444, rmi_driver_firmware_id_show, NULL); 311 312static ssize_t rmi_driver_package_id_show(struct device *dev, 313 struct device_attribute *dattr, 314 char *buf) 315{ 316 struct rmi_driver_data *data = dev_get_drvdata(dev); 317 struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev); 318 319 u32 package_id = f01->properties.package_id; 320 321 return scnprintf(buf, PAGE_SIZE, "%04x.%04x\n", 322 package_id & 0xffff, (package_id >> 16) & 0xffff); 323} 324 325static DEVICE_ATTR(package_id, 0444, rmi_driver_package_id_show, NULL); 326 327static struct attribute *rmi_f01_attrs[] = { 328 &dev_attr_manufacturer_id.attr, 329 &dev_attr_date_of_manufacture.attr, 330 &dev_attr_product_id.attr, 331 &dev_attr_firmware_id.attr, 332 &dev_attr_package_id.attr, 333 NULL 334}; 335 336static const struct attribute_group rmi_f01_attr_group = { 337 .attrs = rmi_f01_attrs, 338}; 339 340#ifdef CONFIG_OF 341static int rmi_f01_of_probe(struct device *dev, 342 struct rmi_device_platform_data *pdata) 343{ 344 int retval; 345 u32 val; 346 347 retval = rmi_of_property_read_u32(dev, 348 (u32 *)&pdata->power_management.nosleep, 349 "syna,nosleep-mode", 1); 350 if (retval) 351 return retval; 352 353 retval = rmi_of_property_read_u32(dev, &val, 354 "syna,wakeup-threshold", 1); 355 if (retval) 356 return retval; 357 358 pdata->power_management.wakeup_threshold = val; 359 360 retval = rmi_of_property_read_u32(dev, &val, 361 "syna,doze-holdoff-ms", 1); 362 if (retval) 363 return retval; 364 365 pdata->power_management.doze_holdoff = val * 100; 366 367 retval = rmi_of_property_read_u32(dev, &val, 368 "syna,doze-interval-ms", 1); 369 if (retval) 370 return retval; 371 372 pdata->power_management.doze_interval = val / 10; 373 374 return 0; 375} 376#else 377static inline int rmi_f01_of_probe(struct device *dev, 378 struct rmi_device_platform_data *pdata) 379{ 380 return -ENODEV; 381} 382#endif 383 384static int rmi_f01_probe(struct rmi_function *fn) 385{ 386 struct rmi_device *rmi_dev = fn->rmi_dev; 387 struct rmi_driver_data *driver_data = dev_get_drvdata(&rmi_dev->dev); 388 struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev); 389 struct f01_data *f01; 390 int error; 391 u16 ctrl_base_addr = fn->fd.control_base_addr; 392 u8 device_status; 393 u8 temp; 394 395 if (fn->dev.of_node) { 396 error = rmi_f01_of_probe(&fn->dev, pdata); 397 if (error) 398 return error; 399 } 400 401 f01 = devm_kzalloc(&fn->dev, sizeof(struct f01_data), GFP_KERNEL); 402 if (!f01) 403 return -ENOMEM; 404 405 f01->num_of_irq_regs = driver_data->num_of_irq_regs; 406 407 /* 408 * Set the configured bit and (optionally) other important stuff 409 * in the device control register. 410 */ 411 412 error = rmi_read(rmi_dev, fn->fd.control_base_addr, 413 &f01->device_control.ctrl0); 414 if (error) { 415 dev_err(&fn->dev, "Failed to read F01 control: %d\n", error); 416 return error; 417 } 418 419 switch (pdata->power_management.nosleep) { 420 case RMI_REG_STATE_DEFAULT: 421 break; 422 case RMI_REG_STATE_OFF: 423 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_NOSLEEP_BIT; 424 break; 425 case RMI_REG_STATE_ON: 426 f01->device_control.ctrl0 |= RMI_F01_CTRL0_NOSLEEP_BIT; 427 break; 428 } 429 430 /* 431 * Sleep mode might be set as a hangover from a system crash or 432 * reboot without power cycle. If so, clear it so the sensor 433 * is certain to function. 434 */ 435 if ((f01->device_control.ctrl0 & RMI_F01_CTRL0_SLEEP_MODE_MASK) != 436 RMI_SLEEP_MODE_NORMAL) { 437 dev_warn(&fn->dev, 438 "WARNING: Non-zero sleep mode found. Clearing...\n"); 439 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK; 440 } 441 442 f01->device_control.ctrl0 |= RMI_F01_CTRL0_CONFIGURED_BIT; 443 444 error = rmi_write(rmi_dev, fn->fd.control_base_addr, 445 f01->device_control.ctrl0); 446 if (error) { 447 dev_err(&fn->dev, "Failed to write F01 control: %d\n", error); 448 return error; 449 } 450 451 /* Dummy read in order to clear irqs */ 452 error = rmi_read(rmi_dev, fn->fd.data_base_addr + 1, &temp); 453 if (error < 0) { 454 dev_err(&fn->dev, "Failed to read Interrupt Status.\n"); 455 return error; 456 } 457 458 error = rmi_f01_read_properties(rmi_dev, fn->fd.query_base_addr, 459 &f01->properties); 460 if (error < 0) { 461 dev_err(&fn->dev, "Failed to read F01 properties.\n"); 462 return error; 463 } 464 465 dev_info(&fn->dev, "found RMI device, manufacturer: %s, product: %s, fw id: %d\n", 466 f01->properties.manufacturer_id == 1 ? "Synaptics" : "unknown", 467 f01->properties.product_id, f01->properties.firmware_id); 468 469 /* Advance to interrupt control registers, then skip over them. */ 470 ctrl_base_addr++; 471 ctrl_base_addr += f01->num_of_irq_regs; 472 473 /* read control register */ 474 if (f01->properties.has_adjustable_doze) { 475 f01->doze_interval_addr = ctrl_base_addr; 476 ctrl_base_addr++; 477 478 if (pdata->power_management.doze_interval) { 479 f01->device_control.doze_interval = 480 pdata->power_management.doze_interval; 481 error = rmi_write(rmi_dev, f01->doze_interval_addr, 482 f01->device_control.doze_interval); 483 if (error) { 484 dev_err(&fn->dev, 485 "Failed to configure F01 doze interval register: %d\n", 486 error); 487 return error; 488 } 489 } else { 490 error = rmi_read(rmi_dev, f01->doze_interval_addr, 491 &f01->device_control.doze_interval); 492 if (error) { 493 dev_err(&fn->dev, 494 "Failed to read F01 doze interval register: %d\n", 495 error); 496 return error; 497 } 498 } 499 500 f01->wakeup_threshold_addr = ctrl_base_addr; 501 ctrl_base_addr++; 502 503 if (pdata->power_management.wakeup_threshold) { 504 f01->device_control.wakeup_threshold = 505 pdata->power_management.wakeup_threshold; 506 error = rmi_write(rmi_dev, f01->wakeup_threshold_addr, 507 f01->device_control.wakeup_threshold); 508 if (error) { 509 dev_err(&fn->dev, 510 "Failed to configure F01 wakeup threshold register: %d\n", 511 error); 512 return error; 513 } 514 } else { 515 error = rmi_read(rmi_dev, f01->wakeup_threshold_addr, 516 &f01->device_control.wakeup_threshold); 517 if (error < 0) { 518 dev_err(&fn->dev, 519 "Failed to read F01 wakeup threshold register: %d\n", 520 error); 521 return error; 522 } 523 } 524 } 525 526 if (f01->properties.has_lts) 527 ctrl_base_addr++; 528 529 if (f01->properties.has_adjustable_doze_holdoff) { 530 f01->doze_holdoff_addr = ctrl_base_addr; 531 ctrl_base_addr++; 532 533 if (pdata->power_management.doze_holdoff) { 534 f01->device_control.doze_holdoff = 535 pdata->power_management.doze_holdoff; 536 error = rmi_write(rmi_dev, f01->doze_holdoff_addr, 537 f01->device_control.doze_holdoff); 538 if (error) { 539 dev_err(&fn->dev, 540 "Failed to configure F01 doze holdoff register: %d\n", 541 error); 542 return error; 543 } 544 } else { 545 error = rmi_read(rmi_dev, f01->doze_holdoff_addr, 546 &f01->device_control.doze_holdoff); 547 if (error) { 548 dev_err(&fn->dev, 549 "Failed to read F01 doze holdoff register: %d\n", 550 error); 551 return error; 552 } 553 } 554 } 555 556 error = rmi_read(rmi_dev, fn->fd.data_base_addr, &device_status); 557 if (error < 0) { 558 dev_err(&fn->dev, 559 "Failed to read device status: %d\n", error); 560 return error; 561 } 562 563 if (RMI_F01_STATUS_UNCONFIGURED(device_status)) { 564 dev_err(&fn->dev, 565 "Device was reset during configuration process, status: %#02x!\n", 566 RMI_F01_STATUS_CODE(device_status)); 567 return -EINVAL; 568 } 569 570 dev_set_drvdata(&fn->dev, f01); 571 572 error = sysfs_create_group(&fn->rmi_dev->dev.kobj, &rmi_f01_attr_group); 573 if (error) 574 dev_warn(&fn->dev, "Failed to create sysfs group: %d\n", error); 575 576 return 0; 577} 578 579static void rmi_f01_remove(struct rmi_function *fn) 580{ 581 /* Note that the bus device is used, not the F01 device */ 582 sysfs_remove_group(&fn->rmi_dev->dev.kobj, &rmi_f01_attr_group); 583} 584 585static int rmi_f01_config(struct rmi_function *fn) 586{ 587 struct f01_data *f01 = dev_get_drvdata(&fn->dev); 588 int error; 589 590 error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr, 591 f01->device_control.ctrl0); 592 if (error) { 593 dev_err(&fn->dev, 594 "Failed to write device_control register: %d\n", error); 595 return error; 596 } 597 598 if (f01->properties.has_adjustable_doze) { 599 error = rmi_write(fn->rmi_dev, f01->doze_interval_addr, 600 f01->device_control.doze_interval); 601 if (error) { 602 dev_err(&fn->dev, 603 "Failed to write doze interval: %d\n", error); 604 return error; 605 } 606 607 error = rmi_write_block(fn->rmi_dev, 608 f01->wakeup_threshold_addr, 609 &f01->device_control.wakeup_threshold, 610 sizeof(u8)); 611 if (error) { 612 dev_err(&fn->dev, 613 "Failed to write wakeup threshold: %d\n", 614 error); 615 return error; 616 } 617 } 618 619 if (f01->properties.has_adjustable_doze_holdoff) { 620 error = rmi_write(fn->rmi_dev, f01->doze_holdoff_addr, 621 f01->device_control.doze_holdoff); 622 if (error) { 623 dev_err(&fn->dev, 624 "Failed to write doze holdoff: %d\n", error); 625 return error; 626 } 627 } 628 629 return 0; 630} 631 632static int rmi_f01_suspend(struct rmi_function *fn) 633{ 634 struct f01_data *f01 = dev_get_drvdata(&fn->dev); 635 int error; 636 637 f01->old_nosleep = 638 f01->device_control.ctrl0 & RMI_F01_CTRL0_NOSLEEP_BIT; 639 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_NOSLEEP_BIT; 640 641 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK; 642 if (device_may_wakeup(fn->rmi_dev->xport->dev)) 643 f01->device_control.ctrl0 |= RMI_SLEEP_MODE_RESERVED1; 644 else 645 f01->device_control.ctrl0 |= RMI_SLEEP_MODE_SENSOR_SLEEP; 646 647 error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr, 648 f01->device_control.ctrl0); 649 if (error) { 650 dev_err(&fn->dev, "Failed to write sleep mode: %d.\n", error); 651 if (f01->old_nosleep) 652 f01->device_control.ctrl0 |= RMI_F01_CTRL0_NOSLEEP_BIT; 653 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK; 654 f01->device_control.ctrl0 |= RMI_SLEEP_MODE_NORMAL; 655 return error; 656 } 657 658 return 0; 659} 660 661static int rmi_f01_resume(struct rmi_function *fn) 662{ 663 struct f01_data *f01 = dev_get_drvdata(&fn->dev); 664 int error; 665 666 if (f01->old_nosleep) 667 f01->device_control.ctrl0 |= RMI_F01_CTRL0_NOSLEEP_BIT; 668 669 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK; 670 f01->device_control.ctrl0 |= RMI_SLEEP_MODE_NORMAL; 671 672 error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr, 673 f01->device_control.ctrl0); 674 if (error) { 675 dev_err(&fn->dev, 676 "Failed to restore normal operation: %d.\n", error); 677 return error; 678 } 679 680 return 0; 681} 682 683static irqreturn_t rmi_f01_attention(int irq, void *ctx) 684{ 685 struct rmi_function *fn = ctx; 686 struct rmi_device *rmi_dev = fn->rmi_dev; 687 int error; 688 u8 device_status; 689 690 error = rmi_read(rmi_dev, fn->fd.data_base_addr, &device_status); 691 if (error) { 692 dev_err(&fn->dev, 693 "Failed to read device status: %d.\n", error); 694 return IRQ_RETVAL(error); 695 } 696 697 if (RMI_F01_STATUS_BOOTLOADER(device_status)) 698 dev_warn(&fn->dev, 699 "Device in bootloader mode, please update firmware\n"); 700 701 if (RMI_F01_STATUS_UNCONFIGURED(device_status)) { 702 dev_warn(&fn->dev, "Device reset detected.\n"); 703 error = rmi_dev->driver->reset_handler(rmi_dev); 704 if (error) { 705 dev_err(&fn->dev, "Device reset failed: %d\n", error); 706 return IRQ_RETVAL(error); 707 } 708 } 709 710 return IRQ_HANDLED; 711} 712 713struct rmi_function_handler rmi_f01_handler = { 714 .driver = { 715 .name = "rmi4_f01", 716 /* 717 * Do not allow user unbinding F01 as it is critical 718 * function. 719 */ 720 .suppress_bind_attrs = true, 721 }, 722 .func = 0x01, 723 .probe = rmi_f01_probe, 724 .remove = rmi_f01_remove, 725 .config = rmi_f01_config, 726 .attention = rmi_f01_attention, 727 .suspend = rmi_f01_suspend, 728 .resume = rmi_f01_resume, 729}; 730