drivers/input/touchscreen/mms114.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Melfas MMS114/MMS136/MMS152 touchscreen device driver
   3 //
   4 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   5 // Author: Joonyoung Shim <jy0922.shim@samsung.com>
   6
   7 #include <linux/module.h>
   8 #include <linux/delay.h>
   9 #include <linux/of.h>
  10 #include <linux/i2c.h>
  11 #include <linux/input/mt.h>
  12 #include <linux/input/touchscreen.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/regulator/consumer.h>
  15 #include <linux/slab.h>
  16
  17 /* Write only registers */
  18 #define MMS114_MODE_CONTROL             0x01
  19 #define MMS114_OPERATION_MODE_MASK      0xE
  20 #define MMS114_ACTIVE                   BIT(1)
  21
  22 #define MMS114_XY_RESOLUTION_H          0x02
  23 #define MMS114_X_RESOLUTION             0x03
  24 #define MMS114_Y_RESOLUTION             0x04
  25 #define MMS114_CONTACT_THRESHOLD        0x05
  26 #define MMS114_MOVING_THRESHOLD         0x06
  27
  28 /* Read only registers */
  29 #define MMS114_PACKET_SIZE              0x0F
  30 #define MMS114_INFORMATION              0x10
  31 #define MMS114_TSP_REV                  0xF0
  32
  33 #define MMS152_FW_REV                   0xE1
  34 #define MMS152_COMPAT_GROUP             0xF2
  35
  36 /* Minimum delay time is 50us between stop and start signal of i2c */
  37 #define MMS114_I2C_DELAY                50
  38
  39 /* 200ms needs after power on */
  40 #define MMS114_POWERON_DELAY            200
  41
  42 /* Touchscreen absolute values */
  43 #define MMS114_MAX_AREA                 0xff
  44
  45 #define MMS114_MAX_TOUCHKEYS            15
  46 #define MMS114_MAX_TOUCH                10
  47 #define MMS114_EVENT_SIZE               8
  48 #define MMS136_EVENT_SIZE               6
  49
  50 /* Touch type */
  51 #define MMS114_TYPE_NONE                0
  52 #define MMS114_TYPE_TOUCHSCREEN         1
  53 #define MMS114_TYPE_TOUCHKEY            2
  54
  55 enum mms_type {
  56         TYPE_MMS114     = 114,
  57         TYPE_MMS134S    = 134,
  58         TYPE_MMS136     = 136,
  59         TYPE_MMS152     = 152,
  60         TYPE_MMS345L    = 345,
  61 };
  62
  63 struct mms114_data {
  64         struct i2c_client       *client;
  65         struct input_dev        *input_dev;
  66         struct regulator        *core_reg;
  67         struct regulator        *io_reg;
  68         struct touchscreen_properties props;
  69         enum mms_type           type;
  70         unsigned int            contact_threshold;
  71         unsigned int            moving_threshold;
  72
  73         u32 keycodes[MMS114_MAX_TOUCHKEYS];
  74         int num_keycodes;
  75
  76         /* Use cache data for mode control register(write only) */
  77         u8                      cache_mode_control;
  78 };
  79
  80 struct mms114_touch {
  81         u8 id:4, reserved_bit4:1, type:2, pressed:1;
  82         u8 x_hi:4, y_hi:4;
  83         u8 x_lo;
  84         u8 y_lo;
  85         u8 width;
  86         u8 strength;
  87         u8 reserved[2];
  88 } __packed;
  89
  90 static int __mms114_read_reg(struct mms114_data *data, unsigned int reg,
  91                              unsigned int len, u8 *val)
  92 {
  93         struct i2c_client *client = data->client;
  94         struct i2c_msg xfer[2];
  95         u8 buf = reg & 0xff;
  96         int error;
  97
  98         if (reg <= MMS114_MODE_CONTROL && reg + len > MMS114_MODE_CONTROL)
  99                 BUG();
 100
 101         /* Write register */
 102         xfer[0].addr = client->addr;
 103         xfer[0].flags = client->flags & I2C_M_TEN;
 104         xfer[0].len = 1;
 105         xfer[0].buf = &buf;
 106
 107         /* Read data */
 108         xfer[1].addr = client->addr;
 109         xfer[1].flags = (client->flags & I2C_M_TEN) | I2C_M_RD;
 110         xfer[1].len = len;
 111         xfer[1].buf = val;
 112
 113         error = i2c_transfer(client->adapter, xfer, 2);
 114         if (error != 2) {
 115                 dev_err(&client->dev,
 116                         "%s: i2c transfer failed (%d)\n", __func__, error);
 117                 return error < 0 ? error : -EIO;
 118         }
 119         udelay(MMS114_I2C_DELAY);
 120
 121         return 0;
 122 }
 123
 124 static int mms114_read_reg(struct mms114_data *data, unsigned int reg)
 125 {
 126         u8 val;
 127         int error;
 128
 129         if (reg == MMS114_MODE_CONTROL)
 130                 return data->cache_mode_control;
 131
 132         error = __mms114_read_reg(data, reg, 1, &val);
 133         return error < 0 ? error : val;
 134 }
 135
 136 static int mms114_write_reg(struct mms114_data *data, unsigned int reg,
 137                             unsigned int val)
 138 {
 139         struct i2c_client *client = data->client;
 140         u8 buf[2];
 141         int error;
 142
 143         buf[0] = reg & 0xff;
 144         buf[1] = val & 0xff;
 145
 146         error = i2c_master_send(client, buf, 2);
 147         if (error != 2) {
 148                 dev_err(&client->dev,
 149                         "%s: i2c send failed (%d)\n", __func__, error);
 150                 return error < 0 ? error : -EIO;
 151         }
 152         udelay(MMS114_I2C_DELAY);
 153
 154         if (reg == MMS114_MODE_CONTROL)
 155                 data->cache_mode_control = val;
 156
 157         return 0;
 158 }
 159
 160 static void mms114_process_mt(struct mms114_data *data, struct mms114_touch *touch)
 161 {
 162         struct i2c_client *client = data->client;
 163         struct input_dev *input_dev = data->input_dev;
 164         unsigned int id;
 165         unsigned int x;
 166         unsigned int y;
 167
 168         if (touch->id > MMS114_MAX_TOUCH) {
 169                 dev_err(&client->dev, "Wrong touch id (%d)\n", touch->id);
 170                 return;
 171         }
 172
 173         id = touch->id - 1;
 174         x = touch->x_lo | touch->x_hi << 8;
 175         y = touch->y_lo | touch->y_hi << 8;
 176
 177         dev_dbg(&client->dev,
 178                 "id: %d, type: %d, pressed: %d, x: %d, y: %d, width: %d, strength: %d\n",
 179                 id, touch->type, touch->pressed,
 180                 x, y, touch->width, touch->strength);
 181
 182         input_mt_slot(input_dev, id);
 183         input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, touch->pressed);
 184
 185         if (touch->pressed) {
 186                 touchscreen_report_pos(input_dev, &data->props, x, y, true);
 187                 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, touch->width);
 188                 input_report_abs(input_dev, ABS_MT_PRESSURE, touch->strength);
 189         }
 190 }
 191
 192 static void mms114_process_touchkey(struct mms114_data *data,
 193                                     struct mms114_touch *touch)
 194 {
 195         struct i2c_client *client = data->client;
 196         struct input_dev *input_dev = data->input_dev;
 197         unsigned int keycode_id;
 198
 199         if (touch->id == 0)
 200                 return;
 201
 202         if (touch->id > data->num_keycodes) {
 203                 dev_err(&client->dev, "Wrong touch id for touchkey (%d)\n",
 204                         touch->id);
 205                 return;
 206         }
 207
 208         keycode_id = touch->id - 1;
 209         dev_dbg(&client->dev, "keycode id: %d, pressed: %d\n", keycode_id,
 210                 touch->pressed);
 211
 212         input_report_key(input_dev, data->keycodes[keycode_id], touch->pressed);
 213 }
 214
 215 static irqreturn_t mms114_interrupt(int irq, void *dev_id)
 216 {
 217         struct mms114_data *data = dev_id;
 218         struct i2c_client *client = data->client;
 219         struct input_dev *input_dev = data->input_dev;
 220         struct mms114_touch touch[MMS114_MAX_TOUCH];
 221         int packet_size;
 222         int touch_size;
 223         int index;
 224         int error;
 225
 226         mutex_lock(&input_dev->mutex);
 227         if (!input_device_enabled(input_dev)) {
 228                 mutex_unlock(&input_dev->mutex);
 229                 goto out;
 230         }
 231         mutex_unlock(&input_dev->mutex);
 232
 233         packet_size = mms114_read_reg(data, MMS114_PACKET_SIZE);
 234         if (packet_size <= 0)
 235                 goto out;
 236
 237         /* MMS136 has slightly different event size */
 238         if (data->type == TYPE_MMS134S || data->type == TYPE_MMS136)
 239                 touch_size = packet_size / MMS136_EVENT_SIZE;
 240         else
 241                 touch_size = packet_size / MMS114_EVENT_SIZE;
 242
 243         error = __mms114_read_reg(data, MMS114_INFORMATION, packet_size,
 244                         (u8 *)touch);
 245         if (error < 0)
 246                 goto out;
 247
 248         for (index = 0; index < touch_size; index++) {
 249                 switch (touch[index].type) {
 250                 case MMS114_TYPE_TOUCHSCREEN:
 251                         mms114_process_mt(data, touch + index);
 252                         break;
 253
 254                 case MMS114_TYPE_TOUCHKEY:
 255                         mms114_process_touchkey(data, touch + index);
 256                         break;
 257
 258                 default:
 259                         dev_err(&client->dev, "Wrong touch type (%d)\n",
 260                                 touch[index].type);
 261                         break;
 262                 }
 263         }
 264
 265         input_mt_report_pointer_emulation(data->input_dev, true);
 266         input_sync(data->input_dev);
 267
 268 out:
 269         return IRQ_HANDLED;
 270 }
 271
 272 static int mms114_set_active(struct mms114_data *data, bool active)
 273 {
 274         int val;
 275
 276         val = mms114_read_reg(data, MMS114_MODE_CONTROL);
 277         if (val < 0)
 278                 return val;
 279
 280         val &= ~MMS114_OPERATION_MODE_MASK;
 281
 282         /* If active is false, sleep mode */
 283         if (active)
 284                 val |= MMS114_ACTIVE;
 285
 286         return mms114_write_reg(data, MMS114_MODE_CONTROL, val);
 287 }
 288
 289 static int mms114_get_version(struct mms114_data *data)
 290 {
 291         struct device *dev = &data->client->dev;
 292         u8 buf[6];
 293         int group;
 294         int error;
 295
 296         switch (data->type) {
 297         case TYPE_MMS345L:
 298                 error = __mms114_read_reg(data, MMS152_FW_REV, 3, buf);
 299                 if (error)
 300                         return error;
 301
 302                 dev_info(dev, "TSP FW Rev: bootloader 0x%x / core 0x%x / config 0x%x\n",
 303                          buf[0], buf[1], buf[2]);
 304                 break;
 305
 306         case TYPE_MMS152:
 307                 error = __mms114_read_reg(data, MMS152_FW_REV, 3, buf);
 308                 if (error)
 309                         return error;
 310
 311                 group = i2c_smbus_read_byte_data(data->client,
 312                                                   MMS152_COMPAT_GROUP);
 313                 if (group < 0)
 314                         return group;
 315
 316                 dev_info(dev, "TSP FW Rev: bootloader 0x%x / core 0x%x / config 0x%x, Compat group: %c\n",
 317                          buf[0], buf[1], buf[2], group);
 318                 break;
 319
 320         case TYPE_MMS114:
 321         case TYPE_MMS134S:
 322         case TYPE_MMS136:
 323                 error = __mms114_read_reg(data, MMS114_TSP_REV, 6, buf);
 324                 if (error)
 325                         return error;
 326
 327                 dev_info(dev, "TSP Rev: 0x%x, HW Rev: 0x%x, Firmware Ver: 0x%x\n",
 328                          buf[0], buf[1], buf[3]);
 329                 break;
 330         }
 331
 332         return 0;
 333 }
 334
 335 static int mms114_setup_regs(struct mms114_data *data)
 336 {
 337         const struct touchscreen_properties *props = &data->props;
 338         int val;
 339         int error;
 340
 341         error = mms114_get_version(data);
 342         if (error < 0)
 343                 return error;
 344
 345         /* MMS114, MMS134S and MMS136 have configuration and power on registers */
 346         if (data->type != TYPE_MMS114 && data->type != TYPE_MMS134S &&
 347             data->type != TYPE_MMS136)
 348                 return 0;
 349
 350         error = mms114_set_active(data, true);
 351         if (error < 0)
 352                 return error;
 353
 354         val = (props->max_x >> 8) & 0xf;
 355         val |= ((props->max_y >> 8) & 0xf) << 4;
 356         error = mms114_write_reg(data, MMS114_XY_RESOLUTION_H, val);
 357         if (error < 0)
 358                 return error;
 359
 360         val = props->max_x & 0xff;
 361         error = mms114_write_reg(data, MMS114_X_RESOLUTION, val);
 362         if (error < 0)
 363                 return error;
 364
 365         val = props->max_x & 0xff;
 366         error = mms114_write_reg(data, MMS114_Y_RESOLUTION, val);
 367         if (error < 0)
 368                 return error;
 369
 370         if (data->contact_threshold) {
 371                 error = mms114_write_reg(data, MMS114_CONTACT_THRESHOLD,
 372                                 data->contact_threshold);
 373                 if (error < 0)
 374                         return error;
 375         }
 376
 377         if (data->moving_threshold) {
 378                 error = mms114_write_reg(data, MMS114_MOVING_THRESHOLD,
 379                                 data->moving_threshold);
 380                 if (error < 0)
 381                         return error;
 382         }
 383
 384         return 0;
 385 }
 386
 387 static int mms114_start(struct mms114_data *data)
 388 {
 389         struct i2c_client *client = data->client;
 390         int error;
 391
 392         error = regulator_enable(data->core_reg);
 393         if (error) {
 394                 dev_err(&client->dev, "Failed to enable avdd: %d\n", error);
 395                 return error;
 396         }
 397
 398         error = regulator_enable(data->io_reg);
 399         if (error) {
 400                 dev_err(&client->dev, "Failed to enable vdd: %d\n", error);
 401                 regulator_disable(data->core_reg);
 402                 return error;
 403         }
 404
 405         msleep(MMS114_POWERON_DELAY);
 406
 407         error = mms114_setup_regs(data);
 408         if (error < 0) {
 409                 regulator_disable(data->io_reg);
 410                 regulator_disable(data->core_reg);
 411                 return error;
 412         }
 413
 414         enable_irq(client->irq);
 415
 416         return 0;
 417 }
 418
 419 static void mms114_stop(struct mms114_data *data)
 420 {
 421         struct i2c_client *client = data->client;
 422         int error;
 423
 424         disable_irq(client->irq);
 425
 426         error = regulator_disable(data->io_reg);
 427         if (error)
 428                 dev_warn(&client->dev, "Failed to disable vdd: %d\n", error);
 429
 430         error = regulator_disable(data->core_reg);
 431         if (error)
 432                 dev_warn(&client->dev, "Failed to disable avdd: %d\n", error);
 433 }
 434
 435 static int mms114_input_open(struct input_dev *dev)
 436 {
 437         struct mms114_data *data = input_get_drvdata(dev);
 438
 439         return mms114_start(data);
 440 }
 441
 442 static void mms114_input_close(struct input_dev *dev)
 443 {
 444         struct mms114_data *data = input_get_drvdata(dev);
 445
 446         mms114_stop(data);
 447 }
 448
 449 static int mms114_parse_legacy_bindings(struct mms114_data *data)
 450 {
 451         struct device *dev = &data->client->dev;
 452         struct touchscreen_properties *props = &data->props;
 453
 454         if (device_property_read_u32(dev, "x-size", &props->max_x)) {
 455                 dev_dbg(dev, "failed to get legacy x-size property\n");
 456                 return -EINVAL;
 457         }
 458
 459         if (device_property_read_u32(dev, "y-size", &props->max_y)) {
 460                 dev_dbg(dev, "failed to get legacy y-size property\n");
 461                 return -EINVAL;
 462         }
 463
 464         device_property_read_u32(dev, "contact-threshold",
 465                                 &data->contact_threshold);
 466         device_property_read_u32(dev, "moving-threshold",
 467                                 &data->moving_threshold);
 468
 469         if (device_property_read_bool(dev, "x-invert"))
 470                 props->invert_x = true;
 471         if (device_property_read_bool(dev, "y-invert"))
 472                 props->invert_y = true;
 473
 474         props->swap_x_y = false;
 475
 476         return 0;
 477 }
 478
 479 static int mms114_probe(struct i2c_client *client)
 480 {
 481         struct mms114_data *data;
 482         struct input_dev *input_dev;
 483         const void *match_data;
 484         int error;
 485         int i;
 486
 487         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 488                 dev_err(&client->dev, "Not supported I2C adapter\n");
 489                 return -ENODEV;
 490         }
 491
 492         data = devm_kzalloc(&client->dev, sizeof(struct mms114_data),
 493                             GFP_KERNEL);
 494         input_dev = devm_input_allocate_device(&client->dev);
 495         if (!data || !input_dev) {
 496                 dev_err(&client->dev, "Failed to allocate memory\n");
 497                 return -ENOMEM;
 498         }
 499
 500         data->client = client;
 501         data->input_dev = input_dev;
 502
 503         match_data = device_get_match_data(&client->dev);
 504         if (!match_data)
 505                 return -EINVAL;
 506
 507         data->type = (enum mms_type)match_data;
 508
 509         data->num_keycodes = device_property_count_u32(&client->dev,
 510                                                        "linux,keycodes");
 511         if (data->num_keycodes == -EINVAL) {
 512                 data->num_keycodes = 0;
 513         } else if (data->num_keycodes < 0) {
 514                 dev_err(&client->dev,
 515                         "Unable to parse linux,keycodes property: %d\n",
 516                         data->num_keycodes);
 517                 return data->num_keycodes;
 518         } else if (data->num_keycodes > MMS114_MAX_TOUCHKEYS) {
 519                 dev_warn(&client->dev,
 520                         "Found %d linux,keycodes but max is %d, ignoring the rest\n",
 521                          data->num_keycodes, MMS114_MAX_TOUCHKEYS);
 522                 data->num_keycodes = MMS114_MAX_TOUCHKEYS;
 523         }
 524
 525         if (data->num_keycodes > 0) {
 526                 error = device_property_read_u32_array(&client->dev,
 527                                                        "linux,keycodes",
 528                                                        data->keycodes,
 529                                                        data->num_keycodes);
 530                 if (error) {
 531                         dev_err(&client->dev,
 532                                 "Unable to read linux,keycodes values: %d\n",
 533                                 error);
 534                         return error;
 535                 }
 536
 537                 input_dev->keycode = data->keycodes;
 538                 input_dev->keycodemax = data->num_keycodes;
 539                 input_dev->keycodesize = sizeof(data->keycodes[0]);
 540                 for (i = 0; i < data->num_keycodes; i++)
 541                         input_set_capability(input_dev,
 542                                              EV_KEY, data->keycodes[i]);
 543         }
 544
 545         input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
 546         input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
 547         input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
 548         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
 549                              0, MMS114_MAX_AREA, 0, 0);
 550
 551         touchscreen_parse_properties(input_dev, true, &data->props);
 552         if (!data->props.max_x || !data->props.max_y) {
 553                 dev_dbg(&client->dev,
 554                         "missing X/Y size properties, trying legacy bindings\n");
 555                 error = mms114_parse_legacy_bindings(data);
 556                 if (error)
 557                         return error;
 558
 559                 input_set_abs_params(input_dev, ABS_MT_POSITION_X,
 560                                      0, data->props.max_x, 0, 0);
 561                 input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
 562                                      0, data->props.max_y, 0, 0);
 563         }
 564
 565         if (data->type == TYPE_MMS114 || data->type == TYPE_MMS134S ||
 566             data->type == TYPE_MMS136) {
 567                 /*
 568                  * The firmware handles movement and pressure fuzz, so
 569                  * don't duplicate that in software.
 570                  */
 571                 data->moving_threshold = input_abs_get_fuzz(input_dev,
 572                                                             ABS_MT_POSITION_X);
 573                 data->contact_threshold = input_abs_get_fuzz(input_dev,
 574                                                              ABS_MT_PRESSURE);
 575                 input_abs_set_fuzz(input_dev, ABS_MT_POSITION_X, 0);
 576                 input_abs_set_fuzz(input_dev, ABS_MT_POSITION_Y, 0);
 577                 input_abs_set_fuzz(input_dev, ABS_MT_PRESSURE, 0);
 578         }
 579
 580         input_dev->name = devm_kasprintf(&client->dev, GFP_KERNEL,
 581                                          "MELFAS MMS%d Touchscreen",
 582                                          data->type);
 583         if (!input_dev->name)
 584                 return -ENOMEM;
 585
 586         input_dev->id.bustype = BUS_I2C;
 587         input_dev->dev.parent = &client->dev;
 588         input_dev->open = mms114_input_open;
 589         input_dev->close = mms114_input_close;
 590
 591         error = input_mt_init_slots(input_dev, MMS114_MAX_TOUCH,
 592                                     INPUT_MT_DIRECT);
 593         if (error)
 594                 return error;
 595
 596         input_set_drvdata(input_dev, data);
 597         i2c_set_clientdata(client, data);
 598
 599         data->core_reg = devm_regulator_get(&client->dev, "avdd");
 600         if (IS_ERR(data->core_reg)) {
 601                 error = PTR_ERR(data->core_reg);
 602                 dev_err(&client->dev,
 603                         "Unable to get the Core regulator (%d)\n", error);
 604                 return error;
 605         }
 606
 607         data->io_reg = devm_regulator_get(&client->dev, "vdd");
 608         if (IS_ERR(data->io_reg)) {
 609                 error = PTR_ERR(data->io_reg);
 610                 dev_err(&client->dev,
 611                         "Unable to get the IO regulator (%d)\n", error);
 612                 return error;
 613         }
 614
 615         error = devm_request_threaded_irq(&client->dev, client->irq,
 616                                           NULL, mms114_interrupt,
 617                                           IRQF_ONESHOT | IRQF_NO_AUTOEN,
 618                                           dev_name(&client->dev), data);
 619         if (error) {
 620                 dev_err(&client->dev, "Failed to register interrupt\n");
 621                 return error;
 622         }
 623
 624         error = input_register_device(data->input_dev);
 625         if (error) {
 626                 dev_err(&client->dev, "Failed to register input device\n");
 627                 return error;
 628         }
 629
 630         return 0;
 631 }
 632
 633 static int mms114_suspend(struct device *dev)
 634 {
 635         struct i2c_client *client = to_i2c_client(dev);
 636         struct mms114_data *data = i2c_get_clientdata(client);
 637         struct input_dev *input_dev = data->input_dev;
 638         int id;
 639
 640         /* Release all touch */
 641         for (id = 0; id < MMS114_MAX_TOUCH; id++) {
 642                 input_mt_slot(input_dev, id);
 643                 input_mt_report_slot_inactive(input_dev);
 644         }
 645
 646         input_mt_report_pointer_emulation(input_dev, true);
 647         input_sync(input_dev);
 648
 649         mutex_lock(&input_dev->mutex);
 650         if (input_device_enabled(input_dev))
 651                 mms114_stop(data);
 652         mutex_unlock(&input_dev->mutex);
 653
 654         return 0;
 655 }
 656
 657 static int mms114_resume(struct device *dev)
 658 {
 659         struct i2c_client *client = to_i2c_client(dev);
 660         struct mms114_data *data = i2c_get_clientdata(client);
 661         struct input_dev *input_dev = data->input_dev;
 662         int error;
 663
 664         mutex_lock(&input_dev->mutex);
 665         if (input_device_enabled(input_dev)) {
 666                 error = mms114_start(data);
 667                 if (error < 0) {
 668                         mutex_unlock(&input_dev->mutex);
 669                         return error;
 670                 }
 671         }
 672         mutex_unlock(&input_dev->mutex);
 673
 674         return 0;
 675 }
 676
 677 static DEFINE_SIMPLE_DEV_PM_OPS(mms114_pm_ops, mms114_suspend, mms114_resume);
 678
 679 static const struct i2c_device_id mms114_id[] = {
 680         { "mms114" },
 681         { }
 682 };
 683 MODULE_DEVICE_TABLE(i2c, mms114_id);
 684
 685 #ifdef CONFIG_OF
 686 static const struct of_device_id mms114_dt_match[] = {
 687         {
 688                 .compatible = "melfas,mms114",
 689                 .data = (void *)TYPE_MMS114,
 690         }, {
 691                 .compatible = "melfas,mms134s",
 692                 .data = (void *)TYPE_MMS134S,
 693         }, {
 694                 .compatible = "melfas,mms136",
 695                 .data = (void *)TYPE_MMS136,
 696         }, {
 697                 .compatible = "melfas,mms152",
 698                 .data = (void *)TYPE_MMS152,
 699         }, {
 700                 .compatible = "melfas,mms345l",
 701                 .data = (void *)TYPE_MMS345L,
 702         },
 703         { }
 704 };
 705 MODULE_DEVICE_TABLE(of, mms114_dt_match);
 706 #endif
 707
 708 static struct i2c_driver mms114_driver = {
 709         .driver = {
 710                 .name   = "mms114",
 711                 .pm     = pm_sleep_ptr(&mms114_pm_ops),
 712                 .of_match_table = of_match_ptr(mms114_dt_match),
 713         },
 714         .probe          = mms114_probe,
 715         .id_table       = mms114_id,
 716 };
 717
 718 module_i2c_driver(mms114_driver);
 719
 720 /* Module information */
 721 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
 722 MODULE_DESCRIPTION("MELFAS mms114 Touchscreen driver");
 723 MODULE_LICENSE("GPL v2");