drivers/input/rmi4/rmi_f01.c

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