drivers/input/rmi4/rmi_f01.c

   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 <linux/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
  46 struct 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  */
 116 struct f01_device_control {
 117         u8 ctrl0;
 118         u8 doze_interval;
 119         u8 wakeup_threshold;
 120         u8 doze_holdoff;
 121 };
 122
 123 struct 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
 137 static 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
 256 const 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
 263 static 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 sysfs_emit(buf, "%d\n", f01->properties.manufacturer_id);
 271 }
 272
 273 static DEVICE_ATTR(manufacturer_id, 0444,
 274                    rmi_driver_manufacturer_id_show, NULL);
 275
 276 static ssize_t rmi_driver_dom_show(struct device *dev,
 277                                    struct device_attribute *dattr, char *buf)
 278 {
 279         struct rmi_driver_data *data = dev_get_drvdata(dev);
 280         struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev);
 281
 282         return sysfs_emit(buf, "%s\n", f01->properties.dom);
 283 }
 284
 285 static DEVICE_ATTR(date_of_manufacture, 0444, rmi_driver_dom_show, NULL);
 286
 287 static ssize_t rmi_driver_product_id_show(struct device *dev,
 288                                           struct device_attribute *dattr,
 289                                           char *buf)
 290 {
 291         struct rmi_driver_data *data = dev_get_drvdata(dev);
 292         struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev);
 293
 294         return sysfs_emit(buf, "%s\n", f01->properties.product_id);
 295 }
 296
 297 static DEVICE_ATTR(product_id, 0444, rmi_driver_product_id_show, NULL);
 298
 299 static ssize_t rmi_driver_firmware_id_show(struct device *dev,
 300                                            struct device_attribute *dattr,
 301                                            char *buf)
 302 {
 303         struct rmi_driver_data *data = dev_get_drvdata(dev);
 304         struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev);
 305
 306         return sysfs_emit(buf, "%d\n", f01->properties.firmware_id);
 307 }
 308
 309 static DEVICE_ATTR(firmware_id, 0444, rmi_driver_firmware_id_show, NULL);
 310
 311 static ssize_t rmi_driver_package_id_show(struct device *dev,
 312                                           struct device_attribute *dattr,
 313                                           char *buf)
 314 {
 315         struct rmi_driver_data *data = dev_get_drvdata(dev);
 316         struct f01_data *f01 = dev_get_drvdata(&data->f01_container->dev);
 317
 318         u32 package_id = f01->properties.package_id;
 319
 320         return sysfs_emit(buf, "%04x.%04x\n",
 321                           package_id & 0xffff, (package_id >> 16) & 0xffff);
 322 }
 323
 324 static DEVICE_ATTR(package_id, 0444, rmi_driver_package_id_show, NULL);
 325
 326 static struct attribute *rmi_f01_attrs[] = {
 327         &dev_attr_manufacturer_id.attr,
 328         &dev_attr_date_of_manufacture.attr,
 329         &dev_attr_product_id.attr,
 330         &dev_attr_firmware_id.attr,
 331         &dev_attr_package_id.attr,
 332         NULL
 333 };
 334
 335 static const struct attribute_group rmi_f01_attr_group = {
 336         .attrs = rmi_f01_attrs,
 337 };
 338
 339 #ifdef CONFIG_OF
 340 static int rmi_f01_of_probe(struct device *dev,
 341                                 struct rmi_device_platform_data *pdata)
 342 {
 343         int retval;
 344         u32 val;
 345
 346         retval = rmi_of_property_read_u32(dev,
 347                         (u32 *)&pdata->power_management.nosleep,
 348                         "syna,nosleep-mode", 1);
 349         if (retval)
 350                 return retval;
 351
 352         retval = rmi_of_property_read_u32(dev, &val,
 353                         "syna,wakeup-threshold", 1);
 354         if (retval)
 355                 return retval;
 356
 357         pdata->power_management.wakeup_threshold = val;
 358
 359         retval = rmi_of_property_read_u32(dev, &val,
 360                         "syna,doze-holdoff-ms", 1);
 361         if (retval)
 362                 return retval;
 363
 364         pdata->power_management.doze_holdoff = val * 100;
 365
 366         retval = rmi_of_property_read_u32(dev, &val,
 367                         "syna,doze-interval-ms", 1);
 368         if (retval)
 369                 return retval;
 370
 371         pdata->power_management.doze_interval = val / 10;
 372
 373         return 0;
 374 }
 375 #else
 376 static inline int rmi_f01_of_probe(struct device *dev,
 377                                         struct rmi_device_platform_data *pdata)
 378 {
 379         return -ENODEV;
 380 }
 381 #endif
 382
 383 static int rmi_f01_probe(struct rmi_function *fn)
 384 {
 385         struct rmi_device *rmi_dev = fn->rmi_dev;
 386         struct rmi_driver_data *driver_data = dev_get_drvdata(&rmi_dev->dev);
 387         struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
 388         struct f01_data *f01;
 389         int error;
 390         u16 ctrl_base_addr = fn->fd.control_base_addr;
 391         u8 device_status;
 392         u8 temp;
 393
 394         if (fn->dev.of_node) {
 395                 error = rmi_f01_of_probe(&fn->dev, pdata);
 396                 if (error)
 397                         return error;
 398         }
 399
 400         f01 = devm_kzalloc(&fn->dev, sizeof(struct f01_data), GFP_KERNEL);
 401         if (!f01)
 402                 return -ENOMEM;
 403
 404         f01->num_of_irq_regs = driver_data->num_of_irq_regs;
 405
 406         /*
 407          * Set the configured bit and (optionally) other important stuff
 408          * in the device control register.
 409          */
 410
 411         error = rmi_read(rmi_dev, fn->fd.control_base_addr,
 412                          &f01->device_control.ctrl0);
 413         if (error) {
 414                 dev_err(&fn->dev, "Failed to read F01 control: %d\n", error);
 415                 return error;
 416         }
 417
 418         switch (pdata->power_management.nosleep) {
 419         case RMI_REG_STATE_DEFAULT:
 420                 break;
 421         case RMI_REG_STATE_OFF:
 422                 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_NOSLEEP_BIT;
 423                 break;
 424         case RMI_REG_STATE_ON:
 425                 f01->device_control.ctrl0 |= RMI_F01_CTRL0_NOSLEEP_BIT;
 426                 break;
 427         }
 428
 429         /*
 430          * Sleep mode might be set as a hangover from a system crash or
 431          * reboot without power cycle.  If so, clear it so the sensor
 432          * is certain to function.
 433          */
 434         if ((f01->device_control.ctrl0 & RMI_F01_CTRL0_SLEEP_MODE_MASK) !=
 435                         RMI_SLEEP_MODE_NORMAL) {
 436                 dev_warn(&fn->dev,
 437                          "WARNING: Non-zero sleep mode found. Clearing...\n");
 438                 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
 439         }
 440
 441         f01->device_control.ctrl0 |= RMI_F01_CTRL0_CONFIGURED_BIT;
 442
 443         error = rmi_write(rmi_dev, fn->fd.control_base_addr,
 444                           f01->device_control.ctrl0);
 445         if (error) {
 446                 dev_err(&fn->dev, "Failed to write F01 control: %d\n", error);
 447                 return error;
 448         }
 449
 450         /* Dummy read in order to clear irqs */
 451         error = rmi_read(rmi_dev, fn->fd.data_base_addr + 1, &temp);
 452         if (error < 0) {
 453                 dev_err(&fn->dev, "Failed to read Interrupt Status.\n");
 454                 return error;
 455         }
 456
 457         error = rmi_f01_read_properties(rmi_dev, fn->fd.query_base_addr,
 458                                         &f01->properties);
 459         if (error < 0) {
 460                 dev_err(&fn->dev, "Failed to read F01 properties.\n");
 461                 return error;
 462         }
 463
 464         dev_info(&fn->dev, "found RMI device, manufacturer: %s, product: %s, fw id: %d\n",
 465                  f01->properties.manufacturer_id == 1 ? "Synaptics" : "unknown",
 466                  f01->properties.product_id, f01->properties.firmware_id);
 467
 468         /* Advance to interrupt control registers, then skip over them. */
 469         ctrl_base_addr++;
 470         ctrl_base_addr += f01->num_of_irq_regs;
 471
 472         /* read control register */
 473         if (f01->properties.has_adjustable_doze) {
 474                 f01->doze_interval_addr = ctrl_base_addr;
 475                 ctrl_base_addr++;
 476
 477                 if (pdata->power_management.doze_interval) {
 478                         f01->device_control.doze_interval =
 479                                 pdata->power_management.doze_interval;
 480                         error = rmi_write(rmi_dev, f01->doze_interval_addr,
 481                                           f01->device_control.doze_interval);
 482                         if (error) {
 483                                 dev_err(&fn->dev,
 484                                         "Failed to configure F01 doze interval register: %d\n",
 485                                         error);
 486                                 return error;
 487                         }
 488                 } else {
 489                         error = rmi_read(rmi_dev, f01->doze_interval_addr,
 490                                          &f01->device_control.doze_interval);
 491                         if (error) {
 492                                 dev_err(&fn->dev,
 493                                         "Failed to read F01 doze interval register: %d\n",
 494                                         error);
 495                                 return error;
 496                         }
 497                 }
 498
 499                 f01->wakeup_threshold_addr = ctrl_base_addr;
 500                 ctrl_base_addr++;
 501
 502                 if (pdata->power_management.wakeup_threshold) {
 503                         f01->device_control.wakeup_threshold =
 504                                 pdata->power_management.wakeup_threshold;
 505                         error = rmi_write(rmi_dev, f01->wakeup_threshold_addr,
 506                                           f01->device_control.wakeup_threshold);
 507                         if (error) {
 508                                 dev_err(&fn->dev,
 509                                         "Failed to configure F01 wakeup threshold register: %d\n",
 510                                         error);
 511                                 return error;
 512                         }
 513                 } else {
 514                         error = rmi_read(rmi_dev, f01->wakeup_threshold_addr,
 515                                          &f01->device_control.wakeup_threshold);
 516                         if (error < 0) {
 517                                 dev_err(&fn->dev,
 518                                         "Failed to read F01 wakeup threshold register: %d\n",
 519                                         error);
 520                                 return error;
 521                         }
 522                 }
 523         }
 524
 525         if (f01->properties.has_lts)
 526                 ctrl_base_addr++;
 527
 528         if (f01->properties.has_adjustable_doze_holdoff) {
 529                 f01->doze_holdoff_addr = ctrl_base_addr;
 530                 ctrl_base_addr++;
 531
 532                 if (pdata->power_management.doze_holdoff) {
 533                         f01->device_control.doze_holdoff =
 534                                 pdata->power_management.doze_holdoff;
 535                         error = rmi_write(rmi_dev, f01->doze_holdoff_addr,
 536                                           f01->device_control.doze_holdoff);
 537                         if (error) {
 538                                 dev_err(&fn->dev,
 539                                         "Failed to configure F01 doze holdoff register: %d\n",
 540                                         error);
 541                                 return error;
 542                         }
 543                 } else {
 544                         error = rmi_read(rmi_dev, f01->doze_holdoff_addr,
 545                                          &f01->device_control.doze_holdoff);
 546                         if (error) {
 547                                 dev_err(&fn->dev,
 548                                         "Failed to read F01 doze holdoff register: %d\n",
 549                                         error);
 550                                 return error;
 551                         }
 552                 }
 553         }
 554
 555         error = rmi_read(rmi_dev, fn->fd.data_base_addr, &device_status);
 556         if (error < 0) {
 557                 dev_err(&fn->dev,
 558                         "Failed to read device status: %d\n", error);
 559                 return error;
 560         }
 561
 562         if (RMI_F01_STATUS_UNCONFIGURED(device_status)) {
 563                 dev_err(&fn->dev,
 564                         "Device was reset during configuration process, status: %#02x!\n",
 565                         RMI_F01_STATUS_CODE(device_status));
 566                 return -EINVAL;
 567         }
 568
 569         dev_set_drvdata(&fn->dev, f01);
 570
 571         error = sysfs_create_group(&fn->rmi_dev->dev.kobj, &rmi_f01_attr_group);
 572         if (error)
 573                 dev_warn(&fn->dev, "Failed to create sysfs group: %d\n", error);
 574
 575         return 0;
 576 }
 577
 578 static void rmi_f01_remove(struct rmi_function *fn)
 579 {
 580         /* Note that the bus device is used, not the F01 device */
 581         sysfs_remove_group(&fn->rmi_dev->dev.kobj, &rmi_f01_attr_group);
 582 }
 583
 584 static int rmi_f01_config(struct rmi_function *fn)
 585 {
 586         struct f01_data *f01 = dev_get_drvdata(&fn->dev);
 587         int error;
 588
 589         error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr,
 590                           f01->device_control.ctrl0);
 591         if (error) {
 592                 dev_err(&fn->dev,
 593                         "Failed to write device_control register: %d\n", error);
 594                 return error;
 595         }
 596
 597         if (f01->properties.has_adjustable_doze) {
 598                 error = rmi_write(fn->rmi_dev, f01->doze_interval_addr,
 599                                   f01->device_control.doze_interval);
 600                 if (error) {
 601                         dev_err(&fn->dev,
 602                                 "Failed to write doze interval: %d\n", error);
 603                         return error;
 604                 }
 605
 606                 error = rmi_write_block(fn->rmi_dev,
 607                                          f01->wakeup_threshold_addr,
 608                                          &f01->device_control.wakeup_threshold,
 609                                          sizeof(u8));
 610                 if (error) {
 611                         dev_err(&fn->dev,
 612                                 "Failed to write wakeup threshold: %d\n",
 613                                 error);
 614                         return error;
 615                 }
 616         }
 617
 618         if (f01->properties.has_adjustable_doze_holdoff) {
 619                 error = rmi_write(fn->rmi_dev, f01->doze_holdoff_addr,
 620                                   f01->device_control.doze_holdoff);
 621                 if (error) {
 622                         dev_err(&fn->dev,
 623                                 "Failed to write doze holdoff: %d\n", error);
 624                         return error;
 625                 }
 626         }
 627
 628         return 0;
 629 }
 630
 631 static int rmi_f01_suspend(struct rmi_function *fn)
 632 {
 633         struct f01_data *f01 = dev_get_drvdata(&fn->dev);
 634         int error;
 635
 636         f01->old_nosleep =
 637                 f01->device_control.ctrl0 & RMI_F01_CTRL0_NOSLEEP_BIT;
 638         f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_NOSLEEP_BIT;
 639
 640         f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
 641         if (device_may_wakeup(fn->rmi_dev->xport->dev))
 642                 f01->device_control.ctrl0 |= RMI_SLEEP_MODE_RESERVED1;
 643         else
 644                 f01->device_control.ctrl0 |= RMI_SLEEP_MODE_SENSOR_SLEEP;
 645
 646         error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr,
 647                           f01->device_control.ctrl0);
 648         if (error) {
 649                 dev_err(&fn->dev, "Failed to write sleep mode: %d.\n", error);
 650                 if (f01->old_nosleep)
 651                         f01->device_control.ctrl0 |= RMI_F01_CTRL0_NOSLEEP_BIT;
 652                 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
 653                 f01->device_control.ctrl0 |= RMI_SLEEP_MODE_NORMAL;
 654                 return error;
 655         }
 656
 657         return 0;
 658 }
 659
 660 static int rmi_f01_resume(struct rmi_function *fn)
 661 {
 662         struct f01_data *f01 = dev_get_drvdata(&fn->dev);
 663         int error;
 664
 665         if (f01->old_nosleep)
 666                 f01->device_control.ctrl0 |= RMI_F01_CTRL0_NOSLEEP_BIT;
 667
 668         f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
 669         f01->device_control.ctrl0 |= RMI_SLEEP_MODE_NORMAL;
 670
 671         error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr,
 672                           f01->device_control.ctrl0);
 673         if (error) {
 674                 dev_err(&fn->dev,
 675                         "Failed to restore normal operation: %d.\n", error);
 676                 return error;
 677         }
 678
 679         return 0;
 680 }
 681
 682 static irqreturn_t rmi_f01_attention(int irq, void *ctx)
 683 {
 684         struct rmi_function *fn = ctx;
 685         struct rmi_device *rmi_dev = fn->rmi_dev;
 686         int error;
 687         u8 device_status;
 688
 689         error = rmi_read(rmi_dev, fn->fd.data_base_addr, &device_status);
 690         if (error) {
 691                 dev_err(&fn->dev,
 692                         "Failed to read device status: %d.\n", error);
 693                 return IRQ_RETVAL(error);
 694         }
 695
 696         if (RMI_F01_STATUS_BOOTLOADER(device_status))
 697                 dev_warn(&fn->dev,
 698                          "Device in bootloader mode, please update firmware\n");
 699
 700         if (RMI_F01_STATUS_UNCONFIGURED(device_status)) {
 701                 dev_warn(&fn->dev, "Device reset detected.\n");
 702                 error = rmi_dev->driver->reset_handler(rmi_dev);
 703                 if (error) {
 704                         dev_err(&fn->dev, "Device reset failed: %d\n", error);
 705                         return IRQ_RETVAL(error);
 706                 }
 707         }
 708
 709         return IRQ_HANDLED;
 710 }
 711
 712 struct rmi_function_handler rmi_f01_handler = {
 713         .driver = {
 714                 .name   = "rmi4_f01",
 715                 /*
 716                  * Do not allow user unbinding F01 as it is critical
 717                  * function.
 718                  */
 719                 .suppress_bind_attrs = true,
 720         },
 721         .func           = 0x01,
 722         .probe          = rmi_f01_probe,
 723         .remove         = rmi_f01_remove,
 724         .config         = rmi_f01_config,
 725         .attention      = rmi_f01_attention,
 726         .suspend        = rmi_f01_suspend,
 727         .resume         = rmi_f01_resume,
 728 };