Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 // Melfas MMS114/MMS136/MMS152 touchscreen device driver
0003 //
0004 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
0005 // Author: Joonyoung Shim <jy0922.shim@samsung.com>
0006 
0007 #include <linux/module.h>
0008 #include <linux/delay.h>
0009 #include <linux/of.h>
0010 #include <linux/of_device.h>
0011 #include <linux/i2c.h>
0012 #include <linux/input/mt.h>
0013 #include <linux/input/touchscreen.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/regulator/consumer.h>
0016 #include <linux/slab.h>
0017 
0018 /* Write only registers */
0019 #define MMS114_MODE_CONTROL     0x01
0020 #define MMS114_OPERATION_MODE_MASK  0xE
0021 #define MMS114_ACTIVE           BIT(1)
0022 
0023 #define MMS114_XY_RESOLUTION_H      0x02
0024 #define MMS114_X_RESOLUTION     0x03
0025 #define MMS114_Y_RESOLUTION     0x04
0026 #define MMS114_CONTACT_THRESHOLD    0x05
0027 #define MMS114_MOVING_THRESHOLD     0x06
0028 
0029 /* Read only registers */
0030 #define MMS114_PACKET_SIZE      0x0F
0031 #define MMS114_INFORMATION      0x10
0032 #define MMS114_TSP_REV          0xF0
0033 
0034 #define MMS152_FW_REV           0xE1
0035 #define MMS152_COMPAT_GROUP     0xF2
0036 
0037 /* Minimum delay time is 50us between stop and start signal of i2c */
0038 #define MMS114_I2C_DELAY        50
0039 
0040 /* 200ms needs after power on */
0041 #define MMS114_POWERON_DELAY        200
0042 
0043 /* Touchscreen absolute values */
0044 #define MMS114_MAX_AREA         0xff
0045 
0046 #define MMS114_MAX_TOUCH        10
0047 #define MMS114_EVENT_SIZE       8
0048 #define MMS136_EVENT_SIZE       6
0049 
0050 /* Touch type */
0051 #define MMS114_TYPE_NONE        0
0052 #define MMS114_TYPE_TOUCHSCREEN     1
0053 #define MMS114_TYPE_TOUCHKEY        2
0054 
0055 enum mms_type {
0056     TYPE_MMS114 = 114,
0057     TYPE_MMS134S    = 134,
0058     TYPE_MMS136 = 136,
0059     TYPE_MMS152 = 152,
0060     TYPE_MMS345L    = 345,
0061 };
0062 
0063 struct mms114_data {
0064     struct i2c_client   *client;
0065     struct input_dev    *input_dev;
0066     struct regulator    *core_reg;
0067     struct regulator    *io_reg;
0068     struct touchscreen_properties props;
0069     enum mms_type       type;
0070     unsigned int        contact_threshold;
0071     unsigned int        moving_threshold;
0072 
0073     /* Use cache data for mode control register(write only) */
0074     u8          cache_mode_control;
0075 };
0076 
0077 struct mms114_touch {
0078     u8 id:4, reserved_bit4:1, type:2, pressed:1;
0079     u8 x_hi:4, y_hi:4;
0080     u8 x_lo;
0081     u8 y_lo;
0082     u8 width;
0083     u8 strength;
0084     u8 reserved[2];
0085 } __packed;
0086 
0087 static int __mms114_read_reg(struct mms114_data *data, unsigned int reg,
0088                  unsigned int len, u8 *val)
0089 {
0090     struct i2c_client *client = data->client;
0091     struct i2c_msg xfer[2];
0092     u8 buf = reg & 0xff;
0093     int error;
0094 
0095     if (reg <= MMS114_MODE_CONTROL && reg + len > MMS114_MODE_CONTROL)
0096         BUG();
0097 
0098     /* Write register */
0099     xfer[0].addr = client->addr;
0100     xfer[0].flags = client->flags & I2C_M_TEN;
0101     xfer[0].len = 1;
0102     xfer[0].buf = &buf;
0103 
0104     /* Read data */
0105     xfer[1].addr = client->addr;
0106     xfer[1].flags = (client->flags & I2C_M_TEN) | I2C_M_RD;
0107     xfer[1].len = len;
0108     xfer[1].buf = val;
0109 
0110     error = i2c_transfer(client->adapter, xfer, 2);
0111     if (error != 2) {
0112         dev_err(&client->dev,
0113             "%s: i2c transfer failed (%d)\n", __func__, error);
0114         return error < 0 ? error : -EIO;
0115     }
0116     udelay(MMS114_I2C_DELAY);
0117 
0118     return 0;
0119 }
0120 
0121 static int mms114_read_reg(struct mms114_data *data, unsigned int reg)
0122 {
0123     u8 val;
0124     int error;
0125 
0126     if (reg == MMS114_MODE_CONTROL)
0127         return data->cache_mode_control;
0128 
0129     error = __mms114_read_reg(data, reg, 1, &val);
0130     return error < 0 ? error : val;
0131 }
0132 
0133 static int mms114_write_reg(struct mms114_data *data, unsigned int reg,
0134                 unsigned int val)
0135 {
0136     struct i2c_client *client = data->client;
0137     u8 buf[2];
0138     int error;
0139 
0140     buf[0] = reg & 0xff;
0141     buf[1] = val & 0xff;
0142 
0143     error = i2c_master_send(client, buf, 2);
0144     if (error != 2) {
0145         dev_err(&client->dev,
0146             "%s: i2c send failed (%d)\n", __func__, error);
0147         return error < 0 ? error : -EIO;
0148     }
0149     udelay(MMS114_I2C_DELAY);
0150 
0151     if (reg == MMS114_MODE_CONTROL)
0152         data->cache_mode_control = val;
0153 
0154     return 0;
0155 }
0156 
0157 static void mms114_process_mt(struct mms114_data *data, struct mms114_touch *touch)
0158 {
0159     struct i2c_client *client = data->client;
0160     struct input_dev *input_dev = data->input_dev;
0161     unsigned int id;
0162     unsigned int x;
0163     unsigned int y;
0164 
0165     if (touch->id > MMS114_MAX_TOUCH) {
0166         dev_err(&client->dev, "Wrong touch id (%d)\n", touch->id);
0167         return;
0168     }
0169 
0170     if (touch->type != MMS114_TYPE_TOUCHSCREEN) {
0171         dev_err(&client->dev, "Wrong touch type (%d)\n", touch->type);
0172         return;
0173     }
0174 
0175     id = touch->id - 1;
0176     x = touch->x_lo | touch->x_hi << 8;
0177     y = touch->y_lo | touch->y_hi << 8;
0178 
0179     dev_dbg(&client->dev,
0180         "id: %d, type: %d, pressed: %d, x: %d, y: %d, width: %d, strength: %d\n",
0181         id, touch->type, touch->pressed,
0182         x, y, touch->width, touch->strength);
0183 
0184     input_mt_slot(input_dev, id);
0185     input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, touch->pressed);
0186 
0187     if (touch->pressed) {
0188         touchscreen_report_pos(input_dev, &data->props, x, y, true);
0189         input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, touch->width);
0190         input_report_abs(input_dev, ABS_MT_PRESSURE, touch->strength);
0191     }
0192 }
0193 
0194 static irqreturn_t mms114_interrupt(int irq, void *dev_id)
0195 {
0196     struct mms114_data *data = dev_id;
0197     struct input_dev *input_dev = data->input_dev;
0198     struct mms114_touch touch[MMS114_MAX_TOUCH];
0199     int packet_size;
0200     int touch_size;
0201     int index;
0202     int error;
0203 
0204     mutex_lock(&input_dev->mutex);
0205     if (!input_device_enabled(input_dev)) {
0206         mutex_unlock(&input_dev->mutex);
0207         goto out;
0208     }
0209     mutex_unlock(&input_dev->mutex);
0210 
0211     packet_size = mms114_read_reg(data, MMS114_PACKET_SIZE);
0212     if (packet_size <= 0)
0213         goto out;
0214 
0215     /* MMS136 has slightly different event size */
0216     if (data->type == TYPE_MMS134S || data->type == TYPE_MMS136)
0217         touch_size = packet_size / MMS136_EVENT_SIZE;
0218     else
0219         touch_size = packet_size / MMS114_EVENT_SIZE;
0220 
0221     error = __mms114_read_reg(data, MMS114_INFORMATION, packet_size,
0222             (u8 *)touch);
0223     if (error < 0)
0224         goto out;
0225 
0226     for (index = 0; index < touch_size; index++)
0227         mms114_process_mt(data, touch + index);
0228 
0229     input_mt_report_pointer_emulation(data->input_dev, true);
0230     input_sync(data->input_dev);
0231 
0232 out:
0233     return IRQ_HANDLED;
0234 }
0235 
0236 static int mms114_set_active(struct mms114_data *data, bool active)
0237 {
0238     int val;
0239 
0240     val = mms114_read_reg(data, MMS114_MODE_CONTROL);
0241     if (val < 0)
0242         return val;
0243 
0244     val &= ~MMS114_OPERATION_MODE_MASK;
0245 
0246     /* If active is false, sleep mode */
0247     if (active)
0248         val |= MMS114_ACTIVE;
0249 
0250     return mms114_write_reg(data, MMS114_MODE_CONTROL, val);
0251 }
0252 
0253 static int mms114_get_version(struct mms114_data *data)
0254 {
0255     struct device *dev = &data->client->dev;
0256     u8 buf[6];
0257     int group;
0258     int error;
0259 
0260     switch (data->type) {
0261     case TYPE_MMS345L:
0262         error = __mms114_read_reg(data, MMS152_FW_REV, 3, buf);
0263         if (error)
0264             return error;
0265 
0266         dev_info(dev, "TSP FW Rev: bootloader 0x%x / core 0x%x / config 0x%x\n",
0267              buf[0], buf[1], buf[2]);
0268         break;
0269 
0270     case TYPE_MMS152:
0271         error = __mms114_read_reg(data, MMS152_FW_REV, 3, buf);
0272         if (error)
0273             return error;
0274 
0275         group = i2c_smbus_read_byte_data(data->client,
0276                           MMS152_COMPAT_GROUP);
0277         if (group < 0)
0278             return group;
0279 
0280         dev_info(dev, "TSP FW Rev: bootloader 0x%x / core 0x%x / config 0x%x, Compat group: %c\n",
0281              buf[0], buf[1], buf[2], group);
0282         break;
0283 
0284     case TYPE_MMS114:
0285     case TYPE_MMS134S:
0286     case TYPE_MMS136:
0287         error = __mms114_read_reg(data, MMS114_TSP_REV, 6, buf);
0288         if (error)
0289             return error;
0290 
0291         dev_info(dev, "TSP Rev: 0x%x, HW Rev: 0x%x, Firmware Ver: 0x%x\n",
0292              buf[0], buf[1], buf[3]);
0293         break;
0294     }
0295 
0296     return 0;
0297 }
0298 
0299 static int mms114_setup_regs(struct mms114_data *data)
0300 {
0301     const struct touchscreen_properties *props = &data->props;
0302     int val;
0303     int error;
0304 
0305     error = mms114_get_version(data);
0306     if (error < 0)
0307         return error;
0308 
0309     /* MMS114, MMS134S and MMS136 have configuration and power on registers */
0310     if (data->type != TYPE_MMS114 && data->type != TYPE_MMS134S &&
0311         data->type != TYPE_MMS136)
0312         return 0;
0313 
0314     error = mms114_set_active(data, true);
0315     if (error < 0)
0316         return error;
0317 
0318     val = (props->max_x >> 8) & 0xf;
0319     val |= ((props->max_y >> 8) & 0xf) << 4;
0320     error = mms114_write_reg(data, MMS114_XY_RESOLUTION_H, val);
0321     if (error < 0)
0322         return error;
0323 
0324     val = props->max_x & 0xff;
0325     error = mms114_write_reg(data, MMS114_X_RESOLUTION, val);
0326     if (error < 0)
0327         return error;
0328 
0329     val = props->max_x & 0xff;
0330     error = mms114_write_reg(data, MMS114_Y_RESOLUTION, val);
0331     if (error < 0)
0332         return error;
0333 
0334     if (data->contact_threshold) {
0335         error = mms114_write_reg(data, MMS114_CONTACT_THRESHOLD,
0336                 data->contact_threshold);
0337         if (error < 0)
0338             return error;
0339     }
0340 
0341     if (data->moving_threshold) {
0342         error = mms114_write_reg(data, MMS114_MOVING_THRESHOLD,
0343                 data->moving_threshold);
0344         if (error < 0)
0345             return error;
0346     }
0347 
0348     return 0;
0349 }
0350 
0351 static int mms114_start(struct mms114_data *data)
0352 {
0353     struct i2c_client *client = data->client;
0354     int error;
0355 
0356     error = regulator_enable(data->core_reg);
0357     if (error) {
0358         dev_err(&client->dev, "Failed to enable avdd: %d\n", error);
0359         return error;
0360     }
0361 
0362     error = regulator_enable(data->io_reg);
0363     if (error) {
0364         dev_err(&client->dev, "Failed to enable vdd: %d\n", error);
0365         regulator_disable(data->core_reg);
0366         return error;
0367     }
0368 
0369     msleep(MMS114_POWERON_DELAY);
0370 
0371     error = mms114_setup_regs(data);
0372     if (error < 0) {
0373         regulator_disable(data->io_reg);
0374         regulator_disable(data->core_reg);
0375         return error;
0376     }
0377 
0378     enable_irq(client->irq);
0379 
0380     return 0;
0381 }
0382 
0383 static void mms114_stop(struct mms114_data *data)
0384 {
0385     struct i2c_client *client = data->client;
0386     int error;
0387 
0388     disable_irq(client->irq);
0389 
0390     error = regulator_disable(data->io_reg);
0391     if (error)
0392         dev_warn(&client->dev, "Failed to disable vdd: %d\n", error);
0393 
0394     error = regulator_disable(data->core_reg);
0395     if (error)
0396         dev_warn(&client->dev, "Failed to disable avdd: %d\n", error);
0397 }
0398 
0399 static int mms114_input_open(struct input_dev *dev)
0400 {
0401     struct mms114_data *data = input_get_drvdata(dev);
0402 
0403     return mms114_start(data);
0404 }
0405 
0406 static void mms114_input_close(struct input_dev *dev)
0407 {
0408     struct mms114_data *data = input_get_drvdata(dev);
0409 
0410     mms114_stop(data);
0411 }
0412 
0413 static int mms114_parse_legacy_bindings(struct mms114_data *data)
0414 {
0415     struct device *dev = &data->client->dev;
0416     struct touchscreen_properties *props = &data->props;
0417 
0418     if (device_property_read_u32(dev, "x-size", &props->max_x)) {
0419         dev_dbg(dev, "failed to get legacy x-size property\n");
0420         return -EINVAL;
0421     }
0422 
0423     if (device_property_read_u32(dev, "y-size", &props->max_y)) {
0424         dev_dbg(dev, "failed to get legacy y-size property\n");
0425         return -EINVAL;
0426     }
0427 
0428     device_property_read_u32(dev, "contact-threshold",
0429                 &data->contact_threshold);
0430     device_property_read_u32(dev, "moving-threshold",
0431                 &data->moving_threshold);
0432 
0433     if (device_property_read_bool(dev, "x-invert"))
0434         props->invert_x = true;
0435     if (device_property_read_bool(dev, "y-invert"))
0436         props->invert_y = true;
0437 
0438     props->swap_x_y = false;
0439 
0440     return 0;
0441 }
0442 
0443 static int mms114_probe(struct i2c_client *client,
0444                   const struct i2c_device_id *id)
0445 {
0446     struct mms114_data *data;
0447     struct input_dev *input_dev;
0448     const void *match_data;
0449     int error;
0450 
0451     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
0452         dev_err(&client->dev, "Not supported I2C adapter\n");
0453         return -ENODEV;
0454     }
0455 
0456     data = devm_kzalloc(&client->dev, sizeof(struct mms114_data),
0457                 GFP_KERNEL);
0458     input_dev = devm_input_allocate_device(&client->dev);
0459     if (!data || !input_dev) {
0460         dev_err(&client->dev, "Failed to allocate memory\n");
0461         return -ENOMEM;
0462     }
0463 
0464     data->client = client;
0465     data->input_dev = input_dev;
0466 
0467     match_data = device_get_match_data(&client->dev);
0468     if (!match_data)
0469         return -EINVAL;
0470 
0471     data->type = (enum mms_type)match_data;
0472 
0473     input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
0474     input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
0475     input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
0476     input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
0477                  0, MMS114_MAX_AREA, 0, 0);
0478 
0479     touchscreen_parse_properties(input_dev, true, &data->props);
0480     if (!data->props.max_x || !data->props.max_y) {
0481         dev_dbg(&client->dev,
0482             "missing X/Y size properties, trying legacy bindings\n");
0483         error = mms114_parse_legacy_bindings(data);
0484         if (error)
0485             return error;
0486 
0487         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
0488                      0, data->props.max_x, 0, 0);
0489         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
0490                      0, data->props.max_y, 0, 0);
0491     }
0492 
0493     if (data->type == TYPE_MMS114 || data->type == TYPE_MMS134S ||
0494         data->type == TYPE_MMS136) {
0495         /*
0496          * The firmware handles movement and pressure fuzz, so
0497          * don't duplicate that in software.
0498          */
0499         data->moving_threshold = input_abs_get_fuzz(input_dev,
0500                                 ABS_MT_POSITION_X);
0501         data->contact_threshold = input_abs_get_fuzz(input_dev,
0502                                  ABS_MT_PRESSURE);
0503         input_abs_set_fuzz(input_dev, ABS_MT_POSITION_X, 0);
0504         input_abs_set_fuzz(input_dev, ABS_MT_POSITION_Y, 0);
0505         input_abs_set_fuzz(input_dev, ABS_MT_PRESSURE, 0);
0506     }
0507 
0508     input_dev->name = devm_kasprintf(&client->dev, GFP_KERNEL,
0509                      "MELFAS MMS%d Touchscreen",
0510                      data->type);
0511     if (!input_dev->name)
0512         return -ENOMEM;
0513 
0514     input_dev->id.bustype = BUS_I2C;
0515     input_dev->dev.parent = &client->dev;
0516     input_dev->open = mms114_input_open;
0517     input_dev->close = mms114_input_close;
0518 
0519     error = input_mt_init_slots(input_dev, MMS114_MAX_TOUCH,
0520                     INPUT_MT_DIRECT);
0521     if (error)
0522         return error;
0523 
0524     input_set_drvdata(input_dev, data);
0525     i2c_set_clientdata(client, data);
0526 
0527     data->core_reg = devm_regulator_get(&client->dev, "avdd");
0528     if (IS_ERR(data->core_reg)) {
0529         error = PTR_ERR(data->core_reg);
0530         dev_err(&client->dev,
0531             "Unable to get the Core regulator (%d)\n", error);
0532         return error;
0533     }
0534 
0535     data->io_reg = devm_regulator_get(&client->dev, "vdd");
0536     if (IS_ERR(data->io_reg)) {
0537         error = PTR_ERR(data->io_reg);
0538         dev_err(&client->dev,
0539             "Unable to get the IO regulator (%d)\n", error);
0540         return error;
0541     }
0542 
0543     error = devm_request_threaded_irq(&client->dev, client->irq,
0544                       NULL, mms114_interrupt,
0545                       IRQF_ONESHOT | IRQF_NO_AUTOEN,
0546                       dev_name(&client->dev), data);
0547     if (error) {
0548         dev_err(&client->dev, "Failed to register interrupt\n");
0549         return error;
0550     }
0551 
0552     error = input_register_device(data->input_dev);
0553     if (error) {
0554         dev_err(&client->dev, "Failed to register input device\n");
0555         return error;
0556     }
0557 
0558     return 0;
0559 }
0560 
0561 static int __maybe_unused mms114_suspend(struct device *dev)
0562 {
0563     struct i2c_client *client = to_i2c_client(dev);
0564     struct mms114_data *data = i2c_get_clientdata(client);
0565     struct input_dev *input_dev = data->input_dev;
0566     int id;
0567 
0568     /* Release all touch */
0569     for (id = 0; id < MMS114_MAX_TOUCH; id++) {
0570         input_mt_slot(input_dev, id);
0571         input_mt_report_slot_inactive(input_dev);
0572     }
0573 
0574     input_mt_report_pointer_emulation(input_dev, true);
0575     input_sync(input_dev);
0576 
0577     mutex_lock(&input_dev->mutex);
0578     if (input_device_enabled(input_dev))
0579         mms114_stop(data);
0580     mutex_unlock(&input_dev->mutex);
0581 
0582     return 0;
0583 }
0584 
0585 static int __maybe_unused mms114_resume(struct device *dev)
0586 {
0587     struct i2c_client *client = to_i2c_client(dev);
0588     struct mms114_data *data = i2c_get_clientdata(client);
0589     struct input_dev *input_dev = data->input_dev;
0590     int error;
0591 
0592     mutex_lock(&input_dev->mutex);
0593     if (input_device_enabled(input_dev)) {
0594         error = mms114_start(data);
0595         if (error < 0) {
0596             mutex_unlock(&input_dev->mutex);
0597             return error;
0598         }
0599     }
0600     mutex_unlock(&input_dev->mutex);
0601 
0602     return 0;
0603 }
0604 
0605 static SIMPLE_DEV_PM_OPS(mms114_pm_ops, mms114_suspend, mms114_resume);
0606 
0607 static const struct i2c_device_id mms114_id[] = {
0608     { "mms114", 0 },
0609     { }
0610 };
0611 MODULE_DEVICE_TABLE(i2c, mms114_id);
0612 
0613 #ifdef CONFIG_OF
0614 static const struct of_device_id mms114_dt_match[] = {
0615     {
0616         .compatible = "melfas,mms114",
0617         .data = (void *)TYPE_MMS114,
0618     }, {
0619         .compatible = "melfas,mms134s",
0620         .data = (void *)TYPE_MMS134S,
0621     }, {
0622         .compatible = "melfas,mms136",
0623         .data = (void *)TYPE_MMS136,
0624     }, {
0625         .compatible = "melfas,mms152",
0626         .data = (void *)TYPE_MMS152,
0627     }, {
0628         .compatible = "melfas,mms345l",
0629         .data = (void *)TYPE_MMS345L,
0630     },
0631     { }
0632 };
0633 MODULE_DEVICE_TABLE(of, mms114_dt_match);
0634 #endif
0635 
0636 static struct i2c_driver mms114_driver = {
0637     .driver = {
0638         .name   = "mms114",
0639         .pm = &mms114_pm_ops,
0640         .of_match_table = of_match_ptr(mms114_dt_match),
0641     },
0642     .probe      = mms114_probe,
0643     .id_table   = mms114_id,
0644 };
0645 
0646 module_i2c_driver(mms114_driver);
0647 
0648 /* Module information */
0649 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
0650 MODULE_DESCRIPTION("MELFAS mms114 Touchscreen driver");
0651 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!