drivers/input/rmi4/rmi_f12.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2012-2016 Synaptics Incorporated
   4  */
   5 #include <linux/input.h>
   6 #include <linux/input/mt.h>
   7 #include <linux/rmi.h>
   8 #include "rmi_driver.h"
   9 #include "rmi_2d_sensor.h"
  10
  11 enum rmi_f12_object_type {
  12         RMI_F12_OBJECT_NONE                     = 0x00,
  13         RMI_F12_OBJECT_FINGER                   = 0x01,
  14         RMI_F12_OBJECT_STYLUS                   = 0x02,
  15         RMI_F12_OBJECT_PALM                     = 0x03,
  16         RMI_F12_OBJECT_UNCLASSIFIED             = 0x04,
  17         RMI_F12_OBJECT_GLOVED_FINGER            = 0x06,
  18         RMI_F12_OBJECT_NARROW_OBJECT            = 0x07,
  19         RMI_F12_OBJECT_HAND_EDGE                = 0x08,
  20         RMI_F12_OBJECT_COVER                    = 0x0A,
  21         RMI_F12_OBJECT_STYLUS_2                 = 0x0B,
  22         RMI_F12_OBJECT_ERASER                   = 0x0C,
  23         RMI_F12_OBJECT_SMALL_OBJECT             = 0x0D,
  24 };
  25
  26 #define F12_DATA1_BYTES_PER_OBJ                 8
  27
  28 struct f12_data {
  29         struct rmi_2d_sensor sensor;
  30         struct rmi_2d_sensor_platform_data sensor_pdata;
  31         bool has_dribble;
  32
  33         u16 data_addr;
  34
  35         struct rmi_register_descriptor query_reg_desc;
  36         struct rmi_register_descriptor control_reg_desc;
  37         struct rmi_register_descriptor data_reg_desc;
  38
  39         /* F12 Data1 describes sensed objects */
  40         const struct rmi_register_desc_item *data1;
  41         u16 data1_offset;
  42
  43         /* F12 Data5 describes finger ACM */
  44         const struct rmi_register_desc_item *data5;
  45         u16 data5_offset;
  46
  47         /* F12 Data5 describes Pen */
  48         const struct rmi_register_desc_item *data6;
  49         u16 data6_offset;
  50
  51
  52         /* F12 Data9 reports relative data */
  53         const struct rmi_register_desc_item *data9;
  54         u16 data9_offset;
  55
  56         const struct rmi_register_desc_item *data15;
  57         u16 data15_offset;
  58 };
  59
  60 static int rmi_f12_read_sensor_tuning(struct f12_data *f12)
  61 {
  62         const struct rmi_register_desc_item *item;
  63         struct rmi_2d_sensor *sensor = &f12->sensor;
  64         struct rmi_function *fn = sensor->fn;
  65         struct rmi_device *rmi_dev = fn->rmi_dev;
  66         int ret;
  67         int offset;
  68         u8 buf[15];
  69         int pitch_x = 0;
  70         int pitch_y = 0;
  71         int rx_receivers = 0;
  72         int tx_receivers = 0;
  73
  74         item = rmi_get_register_desc_item(&f12->control_reg_desc, 8);
  75         if (!item) {
  76                 dev_err(&fn->dev,
  77                         "F12 does not have the sensor tuning control register\n");
  78                 return -ENODEV;
  79         }
  80
  81         offset = rmi_register_desc_calc_reg_offset(&f12->control_reg_desc, 8);
  82
  83         if (item->reg_size > sizeof(buf)) {
  84                 dev_err(&fn->dev,
  85                         "F12 control8 should be no bigger than %zd bytes, not: %ld\n",
  86                         sizeof(buf), item->reg_size);
  87                 return -ENODEV;
  88         }
  89
  90         ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr + offset, buf,
  91                                 item->reg_size);
  92         if (ret)
  93                 return ret;
  94
  95         offset = 0;
  96         if (rmi_register_desc_has_subpacket(item, 0)) {
  97                 sensor->max_x = (buf[offset + 1] << 8) | buf[offset];
  98                 sensor->max_y = (buf[offset + 3] << 8) | buf[offset + 2];
  99                 offset += 4;
 100         }
 101
 102         rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: max_x: %d max_y: %d\n", __func__,
 103                 sensor->max_x, sensor->max_y);
 104
 105         if (rmi_register_desc_has_subpacket(item, 1)) {
 106                 pitch_x = (buf[offset + 1] << 8) | buf[offset];
 107                 pitch_y = (buf[offset + 3] << 8) | buf[offset + 2];
 108                 offset += 4;
 109         }
 110
 111         if (rmi_register_desc_has_subpacket(item, 2)) {
 112                 /* Units 1/128 sensor pitch */
 113                 rmi_dbg(RMI_DEBUG_FN, &fn->dev,
 114                         "%s: Inactive Border xlo:%d xhi:%d ylo:%d yhi:%d\n",
 115                         __func__,
 116                         buf[offset], buf[offset + 1],
 117                         buf[offset + 2], buf[offset + 3]);
 118
 119                 offset += 4;
 120         }
 121
 122         if (rmi_register_desc_has_subpacket(item, 3)) {
 123                 rx_receivers = buf[offset];
 124                 tx_receivers = buf[offset + 1];
 125                 offset += 2;
 126         }
 127
 128         /* Skip over sensor flags */
 129         if (rmi_register_desc_has_subpacket(item, 4))
 130                 offset += 1;
 131
 132         sensor->x_mm = (pitch_x * rx_receivers) >> 12;
 133         sensor->y_mm = (pitch_y * tx_receivers) >> 12;
 134
 135         rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x_mm: %d y_mm: %d\n", __func__,
 136                 sensor->x_mm, sensor->y_mm);
 137
 138         return 0;
 139 }
 140
 141 static void rmi_f12_process_objects(struct f12_data *f12, u8 *data1, int size)
 142 {
 143         int i;
 144         struct rmi_2d_sensor *sensor = &f12->sensor;
 145         int objects = f12->data1->num_subpackets;
 146
 147         if ((f12->data1->num_subpackets * F12_DATA1_BYTES_PER_OBJ) > size)
 148                 objects = size / F12_DATA1_BYTES_PER_OBJ;
 149
 150         for (i = 0; i < objects; i++) {
 151                 struct rmi_2d_sensor_abs_object *obj = &sensor->objs[i];
 152
 153                 obj->type = RMI_2D_OBJECT_NONE;
 154                 obj->mt_tool = MT_TOOL_FINGER;
 155
 156                 switch (data1[0]) {
 157                 case RMI_F12_OBJECT_FINGER:
 158                         obj->type = RMI_2D_OBJECT_FINGER;
 159                         break;
 160                 case RMI_F12_OBJECT_STYLUS:
 161                         obj->type = RMI_2D_OBJECT_STYLUS;
 162                         obj->mt_tool = MT_TOOL_PEN;
 163                         break;
 164                 case RMI_F12_OBJECT_PALM:
 165                         obj->type = RMI_2D_OBJECT_PALM;
 166                         obj->mt_tool = MT_TOOL_PALM;
 167                         break;
 168                 case RMI_F12_OBJECT_UNCLASSIFIED:
 169                         obj->type = RMI_2D_OBJECT_UNCLASSIFIED;
 170                         break;
 171                 }
 172
 173                 obj->x = (data1[2] << 8) | data1[1];
 174                 obj->y = (data1[4] << 8) | data1[3];
 175                 obj->z = data1[5];
 176                 obj->wx = data1[6];
 177                 obj->wy = data1[7];
 178
 179                 rmi_2d_sensor_abs_process(sensor, obj, i);
 180
 181                 data1 += F12_DATA1_BYTES_PER_OBJ;
 182         }
 183
 184         if (sensor->kernel_tracking)
 185                 input_mt_assign_slots(sensor->input,
 186                                       sensor->tracking_slots,
 187                                       sensor->tracking_pos,
 188                                       sensor->nbr_fingers,
 189                                       sensor->dmax);
 190
 191         for (i = 0; i < objects; i++)
 192                 rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
 193 }
 194
 195 static irqreturn_t rmi_f12_attention(int irq, void *ctx)
 196 {
 197         int retval;
 198         struct rmi_function *fn = ctx;
 199         struct rmi_device *rmi_dev = fn->rmi_dev;
 200         struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
 201         struct f12_data *f12 = dev_get_drvdata(&fn->dev);
 202         struct rmi_2d_sensor *sensor = &f12->sensor;
 203         int valid_bytes = sensor->pkt_size;
 204
 205         if (drvdata->attn_data.data) {
 206                 if (sensor->attn_size > drvdata->attn_data.size)
 207                         valid_bytes = drvdata->attn_data.size;
 208                 else
 209                         valid_bytes = sensor->attn_size;
 210                 memcpy(sensor->data_pkt, drvdata->attn_data.data,
 211                         valid_bytes);
 212                 drvdata->attn_data.data += sensor->attn_size;
 213                 drvdata->attn_data.size -= sensor->attn_size;
 214         } else {
 215                 retval = rmi_read_block(rmi_dev, f12->data_addr,
 216                                         sensor->data_pkt, sensor->pkt_size);
 217                 if (retval < 0) {
 218                         dev_err(&fn->dev, "Failed to read object data. Code: %d.\n",
 219                                 retval);
 220                         return IRQ_RETVAL(retval);
 221                 }
 222         }
 223
 224         if (f12->data1)
 225                 rmi_f12_process_objects(f12,
 226                         &sensor->data_pkt[f12->data1_offset], valid_bytes);
 227
 228         input_mt_sync_frame(sensor->input);
 229
 230         return IRQ_HANDLED;
 231 }
 232
 233 static int rmi_f12_write_control_regs(struct rmi_function *fn)
 234 {
 235         int ret;
 236         const struct rmi_register_desc_item *item;
 237         struct rmi_device *rmi_dev = fn->rmi_dev;
 238         struct f12_data *f12 = dev_get_drvdata(&fn->dev);
 239         int control_size;
 240         char buf[3];
 241         u16 control_offset = 0;
 242         u8 subpacket_offset = 0;
 243
 244         if (f12->has_dribble
 245             && (f12->sensor.dribble != RMI_REG_STATE_DEFAULT)) {
 246                 item = rmi_get_register_desc_item(&f12->control_reg_desc, 20);
 247                 if (item) {
 248                         control_offset = rmi_register_desc_calc_reg_offset(
 249                                                 &f12->control_reg_desc, 20);
 250
 251                         /*
 252                          * The byte containing the EnableDribble bit will be
 253                          * in either byte 0 or byte 2 of control 20. Depending
 254                          * on the existence of subpacket 0. If control 20 is
 255                          * larger then 3 bytes, just read the first 3.
 256                          */
 257                         control_size = min(item->reg_size, 3UL);
 258
 259                         ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr
 260                                         + control_offset, buf, control_size);
 261                         if (ret)
 262                                 return ret;
 263
 264                         if (rmi_register_desc_has_subpacket(item, 0))
 265                                 subpacket_offset += 1;
 266
 267                         switch (f12->sensor.dribble) {
 268                         case RMI_REG_STATE_OFF:
 269                                 buf[subpacket_offset] &= ~BIT(2);
 270                                 break;
 271                         case RMI_REG_STATE_ON:
 272                                 buf[subpacket_offset] |= BIT(2);
 273                                 break;
 274                         case RMI_REG_STATE_DEFAULT:
 275                         default:
 276                                 break;
 277                         }
 278
 279                         ret = rmi_write_block(rmi_dev,
 280                                 fn->fd.control_base_addr + control_offset,
 281                                 buf, control_size);
 282                         if (ret)
 283                                 return ret;
 284                 }
 285         }
 286
 287         return 0;
 288
 289 }
 290
 291 static int rmi_f12_config(struct rmi_function *fn)
 292 {
 293         struct rmi_driver *drv = fn->rmi_dev->driver;
 294         int ret;
 295
 296         drv->set_irq_bits(fn->rmi_dev, fn->irq_mask);
 297
 298         ret = rmi_f12_write_control_regs(fn);
 299         if (ret)
 300                 dev_warn(&fn->dev,
 301                         "Failed to write F12 control registers: %d\n", ret);
 302
 303         return 0;
 304 }
 305
 306 static int rmi_f12_probe(struct rmi_function *fn)
 307 {
 308         struct f12_data *f12;
 309         int ret;
 310         struct rmi_device *rmi_dev = fn->rmi_dev;
 311         char buf;
 312         u16 query_addr = fn->fd.query_base_addr;
 313         const struct rmi_register_desc_item *item;
 314         struct rmi_2d_sensor *sensor;
 315         struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
 316         struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
 317         u16 data_offset = 0;
 318
 319         rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s\n", __func__);
 320
 321         ret = rmi_read(fn->rmi_dev, query_addr, &buf);
 322         if (ret < 0) {
 323                 dev_err(&fn->dev, "Failed to read general info register: %d\n",
 324                         ret);
 325                 return -ENODEV;
 326         }
 327         ++query_addr;
 328
 329         if (!(buf & BIT(0))) {
 330                 dev_err(&fn->dev,
 331                         "Behavior of F12 without register descriptors is undefined.\n");
 332                 return -ENODEV;
 333         }
 334
 335         f12 = devm_kzalloc(&fn->dev, sizeof(struct f12_data), GFP_KERNEL);
 336         if (!f12)
 337                 return -ENOMEM;
 338
 339         f12->has_dribble = !!(buf & BIT(3));
 340
 341         if (fn->dev.of_node) {
 342                 ret = rmi_2d_sensor_of_probe(&fn->dev, &f12->sensor_pdata);
 343                 if (ret)
 344                         return ret;
 345         } else {
 346                 f12->sensor_pdata = pdata->sensor_pdata;
 347         }
 348
 349         ret = rmi_read_register_desc(rmi_dev, query_addr,
 350                                         &f12->query_reg_desc);
 351         if (ret) {
 352                 dev_err(&fn->dev,
 353                         "Failed to read the Query Register Descriptor: %d\n",
 354                         ret);
 355                 return ret;
 356         }
 357         query_addr += 3;
 358
 359         ret = rmi_read_register_desc(rmi_dev, query_addr,
 360                                                 &f12->control_reg_desc);
 361         if (ret) {
 362                 dev_err(&fn->dev,
 363                         "Failed to read the Control Register Descriptor: %d\n",
 364                         ret);
 365                 return ret;
 366         }
 367         query_addr += 3;
 368
 369         ret = rmi_read_register_desc(rmi_dev, query_addr,
 370                                                 &f12->data_reg_desc);
 371         if (ret) {
 372                 dev_err(&fn->dev,
 373                         "Failed to read the Data Register Descriptor: %d\n",
 374                         ret);
 375                 return ret;
 376         }
 377         query_addr += 3;
 378
 379         sensor = &f12->sensor;
 380         sensor->fn = fn;
 381         f12->data_addr = fn->fd.data_base_addr;
 382         sensor->pkt_size = rmi_register_desc_calc_size(&f12->data_reg_desc);
 383
 384         sensor->axis_align =
 385                 f12->sensor_pdata.axis_align;
 386
 387         sensor->x_mm = f12->sensor_pdata.x_mm;
 388         sensor->y_mm = f12->sensor_pdata.y_mm;
 389         sensor->dribble = f12->sensor_pdata.dribble;
 390
 391         if (sensor->sensor_type == rmi_sensor_default)
 392                 sensor->sensor_type =
 393                         f12->sensor_pdata.sensor_type;
 394
 395         rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: data packet size: %d\n", __func__,
 396                 sensor->pkt_size);
 397         sensor->data_pkt = devm_kzalloc(&fn->dev, sensor->pkt_size, GFP_KERNEL);
 398         if (!sensor->data_pkt)
 399                 return -ENOMEM;
 400
 401         dev_set_drvdata(&fn->dev, f12);
 402
 403         ret = rmi_f12_read_sensor_tuning(f12);
 404         if (ret)
 405                 return ret;
 406
 407         /*
 408          * Figure out what data is contained in the data registers. HID devices
 409          * may have registers defined, but their data is not reported in the
 410          * HID attention report. Registers which are not reported in the HID
 411          * attention report check to see if the device is receiving data from
 412          * HID attention reports.
 413          */
 414         item = rmi_get_register_desc_item(&f12->data_reg_desc, 0);
 415         if (item && !drvdata->attn_data.data)
 416                 data_offset += item->reg_size;
 417
 418         item = rmi_get_register_desc_item(&f12->data_reg_desc, 1);
 419         if (item) {
 420                 f12->data1 = item;
 421                 f12->data1_offset = data_offset;
 422                 data_offset += item->reg_size;
 423                 sensor->nbr_fingers = item->num_subpackets;
 424                 sensor->report_abs = 1;
 425                 sensor->attn_size += item->reg_size;
 426         }
 427
 428         item = rmi_get_register_desc_item(&f12->data_reg_desc, 2);
 429         if (item && !drvdata->attn_data.data)
 430                 data_offset += item->reg_size;
 431
 432         item = rmi_get_register_desc_item(&f12->data_reg_desc, 3);
 433         if (item && !drvdata->attn_data.data)
 434                 data_offset += item->reg_size;
 435
 436         item = rmi_get_register_desc_item(&f12->data_reg_desc, 4);
 437         if (item && !drvdata->attn_data.data)
 438                 data_offset += item->reg_size;
 439
 440         item = rmi_get_register_desc_item(&f12->data_reg_desc, 5);
 441         if (item) {
 442                 f12->data5 = item;
 443                 f12->data5_offset = data_offset;
 444                 data_offset += item->reg_size;
 445                 sensor->attn_size += item->reg_size;
 446         }
 447
 448         item = rmi_get_register_desc_item(&f12->data_reg_desc, 6);
 449         if (item && !drvdata->attn_data.data) {
 450                 f12->data6 = item;
 451                 f12->data6_offset = data_offset;
 452                 data_offset += item->reg_size;
 453         }
 454
 455         item = rmi_get_register_desc_item(&f12->data_reg_desc, 7);
 456         if (item && !drvdata->attn_data.data)
 457                 data_offset += item->reg_size;
 458
 459         item = rmi_get_register_desc_item(&f12->data_reg_desc, 8);
 460         if (item && !drvdata->attn_data.data)
 461                 data_offset += item->reg_size;
 462
 463         item = rmi_get_register_desc_item(&f12->data_reg_desc, 9);
 464         if (item && !drvdata->attn_data.data) {
 465                 f12->data9 = item;
 466                 f12->data9_offset = data_offset;
 467                 data_offset += item->reg_size;
 468                 if (!sensor->report_abs)
 469                         sensor->report_rel = 1;
 470         }
 471
 472         item = rmi_get_register_desc_item(&f12->data_reg_desc, 10);
 473         if (item && !drvdata->attn_data.data)
 474                 data_offset += item->reg_size;
 475
 476         item = rmi_get_register_desc_item(&f12->data_reg_desc, 11);
 477         if (item && !drvdata->attn_data.data)
 478                 data_offset += item->reg_size;
 479
 480         item = rmi_get_register_desc_item(&f12->data_reg_desc, 12);
 481         if (item && !drvdata->attn_data.data)
 482                 data_offset += item->reg_size;
 483
 484         item = rmi_get_register_desc_item(&f12->data_reg_desc, 13);
 485         if (item && !drvdata->attn_data.data)
 486                 data_offset += item->reg_size;
 487
 488         item = rmi_get_register_desc_item(&f12->data_reg_desc, 14);
 489         if (item && !drvdata->attn_data.data)
 490                 data_offset += item->reg_size;
 491
 492         item = rmi_get_register_desc_item(&f12->data_reg_desc, 15);
 493         if (item && !drvdata->attn_data.data) {
 494                 f12->data15 = item;
 495                 f12->data15_offset = data_offset;
 496                 data_offset += item->reg_size;
 497         }
 498
 499         /* allocate the in-kernel tracking buffers */
 500         sensor->tracking_pos = devm_kcalloc(&fn->dev,
 501                         sensor->nbr_fingers, sizeof(struct input_mt_pos),
 502                         GFP_KERNEL);
 503         sensor->tracking_slots = devm_kcalloc(&fn->dev,
 504                         sensor->nbr_fingers, sizeof(int), GFP_KERNEL);
 505         sensor->objs = devm_kcalloc(&fn->dev,
 506                         sensor->nbr_fingers,
 507                         sizeof(struct rmi_2d_sensor_abs_object),
 508                         GFP_KERNEL);
 509         if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs)
 510                 return -ENOMEM;
 511
 512         ret = rmi_2d_sensor_configure_input(fn, sensor);
 513         if (ret)
 514                 return ret;
 515
 516         return 0;
 517 }
 518
 519 struct rmi_function_handler rmi_f12_handler = {
 520         .driver = {
 521                 .name = "rmi4_f12",
 522         },
 523         .func = 0x12,
 524         .probe = rmi_f12_probe,
 525         .config = rmi_f12_config,
 526         .attention = rmi_f12_attention,
 527 };