Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (C) 2012 Simon Budig, <simon.budig@kernelconcepts.de>
0004  * Daniel Wagener <daniel.wagener@kernelconcepts.de> (M09 firmware support)
0005  * Lothar Waßmann <LW@KARO-electronics.de> (DT support)
0006  */
0007 
0008 /*
0009  * This is a driver for the EDT "Polytouch" family of touch controllers
0010  * based on the FocalTech FT5x06 line of chips.
0011  *
0012  * Development of this driver has been sponsored by Glyn:
0013  *    http://www.glyn.com/Products/Displays
0014  */
0015 
0016 #include <linux/debugfs.h>
0017 #include <linux/delay.h>
0018 #include <linux/gpio/consumer.h>
0019 #include <linux/i2c.h>
0020 #include <linux/interrupt.h>
0021 #include <linux/input.h>
0022 #include <linux/input/mt.h>
0023 #include <linux/input/touchscreen.h>
0024 #include <linux/irq.h>
0025 #include <linux/kernel.h>
0026 #include <linux/module.h>
0027 #include <linux/property.h>
0028 #include <linux/ratelimit.h>
0029 #include <linux/regulator/consumer.h>
0030 #include <linux/slab.h>
0031 #include <linux/uaccess.h>
0032 
0033 #include <asm/unaligned.h>
0034 
0035 #define WORK_REGISTER_THRESHOLD     0x00
0036 #define WORK_REGISTER_REPORT_RATE   0x08
0037 #define WORK_REGISTER_GAIN      0x30
0038 #define WORK_REGISTER_OFFSET        0x31
0039 #define WORK_REGISTER_NUM_X     0x33
0040 #define WORK_REGISTER_NUM_Y     0x34
0041 
0042 #define PMOD_REGISTER_ACTIVE        0x00
0043 #define PMOD_REGISTER_HIBERNATE     0x03
0044 
0045 #define M09_REGISTER_THRESHOLD      0x80
0046 #define M09_REGISTER_GAIN       0x92
0047 #define M09_REGISTER_OFFSET     0x93
0048 #define M09_REGISTER_NUM_X      0x94
0049 #define M09_REGISTER_NUM_Y      0x95
0050 
0051 #define M12_REGISTER_REPORT_RATE    0x88
0052 
0053 #define EV_REGISTER_THRESHOLD       0x40
0054 #define EV_REGISTER_GAIN        0x41
0055 #define EV_REGISTER_OFFSET_Y        0x45
0056 #define EV_REGISTER_OFFSET_X        0x46
0057 
0058 #define NO_REGISTER         0xff
0059 
0060 #define WORK_REGISTER_OPMODE        0x3c
0061 #define FACTORY_REGISTER_OPMODE     0x01
0062 #define PMOD_REGISTER_OPMODE        0xa5
0063 
0064 #define TOUCH_EVENT_DOWN        0x00
0065 #define TOUCH_EVENT_UP          0x01
0066 #define TOUCH_EVENT_ON          0x02
0067 #define TOUCH_EVENT_RESERVED        0x03
0068 
0069 #define EDT_NAME_LEN            23
0070 #define EDT_SWITCH_MODE_RETRIES     10
0071 #define EDT_SWITCH_MODE_DELAY       5 /* msec */
0072 #define EDT_RAW_DATA_RETRIES        100
0073 #define EDT_RAW_DATA_DELAY      1000 /* usec */
0074 
0075 #define EDT_DEFAULT_NUM_X       1024
0076 #define EDT_DEFAULT_NUM_Y       1024
0077 
0078 enum edt_pmode {
0079     EDT_PMODE_NOT_SUPPORTED,
0080     EDT_PMODE_HIBERNATE,
0081     EDT_PMODE_POWEROFF,
0082 };
0083 
0084 enum edt_ver {
0085     EDT_M06,
0086     EDT_M09,
0087     EDT_M12,
0088     EV_FT,
0089     GENERIC_FT,
0090 };
0091 
0092 struct edt_reg_addr {
0093     int reg_threshold;
0094     int reg_report_rate;
0095     int reg_gain;
0096     int reg_offset;
0097     int reg_offset_x;
0098     int reg_offset_y;
0099     int reg_num_x;
0100     int reg_num_y;
0101 };
0102 
0103 struct edt_ft5x06_ts_data {
0104     struct i2c_client *client;
0105     struct input_dev *input;
0106     struct touchscreen_properties prop;
0107     u16 num_x;
0108     u16 num_y;
0109     struct regulator *vcc;
0110     struct regulator *iovcc;
0111 
0112     struct gpio_desc *reset_gpio;
0113     struct gpio_desc *wake_gpio;
0114 
0115 #if defined(CONFIG_DEBUG_FS)
0116     struct dentry *debug_dir;
0117     u8 *raw_buffer;
0118     size_t raw_bufsize;
0119 #endif
0120 
0121     struct mutex mutex;
0122     bool factory_mode;
0123     enum edt_pmode suspend_mode;
0124     int threshold;
0125     int gain;
0126     int offset;
0127     int offset_x;
0128     int offset_y;
0129     int report_rate;
0130     int max_support_points;
0131 
0132     char name[EDT_NAME_LEN];
0133     char fw_version[EDT_NAME_LEN];
0134 
0135     struct edt_reg_addr reg_addr;
0136     enum edt_ver version;
0137     unsigned int crc_errors;
0138     unsigned int header_errors;
0139 };
0140 
0141 struct edt_i2c_chip_data {
0142     int  max_support_points;
0143 };
0144 
0145 static int edt_ft5x06_ts_readwrite(struct i2c_client *client,
0146                    u16 wr_len, u8 *wr_buf,
0147                    u16 rd_len, u8 *rd_buf)
0148 {
0149     struct i2c_msg wrmsg[2];
0150     int i = 0;
0151     int ret;
0152 
0153     if (wr_len) {
0154         wrmsg[i].addr  = client->addr;
0155         wrmsg[i].flags = 0;
0156         wrmsg[i].len = wr_len;
0157         wrmsg[i].buf = wr_buf;
0158         i++;
0159     }
0160     if (rd_len) {
0161         wrmsg[i].addr  = client->addr;
0162         wrmsg[i].flags = I2C_M_RD;
0163         wrmsg[i].len = rd_len;
0164         wrmsg[i].buf = rd_buf;
0165         i++;
0166     }
0167 
0168     ret = i2c_transfer(client->adapter, wrmsg, i);
0169     if (ret < 0)
0170         return ret;
0171     if (ret != i)
0172         return -EIO;
0173 
0174     return 0;
0175 }
0176 
0177 static bool edt_ft5x06_ts_check_crc(struct edt_ft5x06_ts_data *tsdata,
0178                     u8 *buf, int buflen)
0179 {
0180     int i;
0181     u8 crc = 0;
0182 
0183     for (i = 0; i < buflen - 1; i++)
0184         crc ^= buf[i];
0185 
0186     if (crc != buf[buflen-1]) {
0187         tsdata->crc_errors++;
0188         dev_err_ratelimited(&tsdata->client->dev,
0189                     "crc error: 0x%02x expected, got 0x%02x\n",
0190                     crc, buf[buflen-1]);
0191         return false;
0192     }
0193 
0194     return true;
0195 }
0196 
0197 static irqreturn_t edt_ft5x06_ts_isr(int irq, void *dev_id)
0198 {
0199     struct edt_ft5x06_ts_data *tsdata = dev_id;
0200     struct device *dev = &tsdata->client->dev;
0201     u8 cmd;
0202     u8 rdbuf[63];
0203     int i, type, x, y, id;
0204     int offset, tplen, datalen, crclen;
0205     int error;
0206 
0207     switch (tsdata->version) {
0208     case EDT_M06:
0209         cmd = 0xf9; /* tell the controller to send touch data */
0210         offset = 5; /* where the actual touch data starts */
0211         tplen = 4;  /* data comes in so called frames */
0212         crclen = 1; /* length of the crc data */
0213         break;
0214 
0215     case EDT_M09:
0216     case EDT_M12:
0217     case EV_FT:
0218     case GENERIC_FT:
0219         cmd = 0x0;
0220         offset = 3;
0221         tplen = 6;
0222         crclen = 0;
0223         break;
0224 
0225     default:
0226         goto out;
0227     }
0228 
0229     memset(rdbuf, 0, sizeof(rdbuf));
0230     datalen = tplen * tsdata->max_support_points + offset + crclen;
0231 
0232     error = edt_ft5x06_ts_readwrite(tsdata->client,
0233                     sizeof(cmd), &cmd,
0234                     datalen, rdbuf);
0235     if (error) {
0236         dev_err_ratelimited(dev, "Unable to fetch data, error: %d\n",
0237                     error);
0238         goto out;
0239     }
0240 
0241     /* M09/M12 does not send header or CRC */
0242     if (tsdata->version == EDT_M06) {
0243         if (rdbuf[0] != 0xaa || rdbuf[1] != 0xaa ||
0244             rdbuf[2] != datalen) {
0245             tsdata->header_errors++;
0246             dev_err_ratelimited(dev,
0247                     "Unexpected header: %02x%02x%02x!\n",
0248                     rdbuf[0], rdbuf[1], rdbuf[2]);
0249             goto out;
0250         }
0251 
0252         if (!edt_ft5x06_ts_check_crc(tsdata, rdbuf, datalen))
0253             goto out;
0254     }
0255 
0256     for (i = 0; i < tsdata->max_support_points; i++) {
0257         u8 *buf = &rdbuf[i * tplen + offset];
0258 
0259         type = buf[0] >> 6;
0260         /* ignore Reserved events */
0261         if (type == TOUCH_EVENT_RESERVED)
0262             continue;
0263 
0264         /* M06 sometimes sends bogus coordinates in TOUCH_DOWN */
0265         if (tsdata->version == EDT_M06 && type == TOUCH_EVENT_DOWN)
0266             continue;
0267 
0268         x = get_unaligned_be16(buf) & 0x0fff;
0269         y = get_unaligned_be16(buf + 2) & 0x0fff;
0270         /* The FT5x26 send the y coordinate first */
0271         if (tsdata->version == EV_FT)
0272             swap(x, y);
0273 
0274         id = (buf[2] >> 4) & 0x0f;
0275 
0276         input_mt_slot(tsdata->input, id);
0277         if (input_mt_report_slot_state(tsdata->input, MT_TOOL_FINGER,
0278                            type != TOUCH_EVENT_UP))
0279             touchscreen_report_pos(tsdata->input, &tsdata->prop,
0280                            x, y, true);
0281     }
0282 
0283     input_mt_report_pointer_emulation(tsdata->input, true);
0284     input_sync(tsdata->input);
0285 
0286 out:
0287     return IRQ_HANDLED;
0288 }
0289 
0290 static int edt_ft5x06_register_write(struct edt_ft5x06_ts_data *tsdata,
0291                      u8 addr, u8 value)
0292 {
0293     u8 wrbuf[4];
0294 
0295     switch (tsdata->version) {
0296     case EDT_M06:
0297         wrbuf[0] = tsdata->factory_mode ? 0xf3 : 0xfc;
0298         wrbuf[1] = tsdata->factory_mode ? addr & 0x7f : addr & 0x3f;
0299         wrbuf[2] = value;
0300         wrbuf[3] = wrbuf[0] ^ wrbuf[1] ^ wrbuf[2];
0301         return edt_ft5x06_ts_readwrite(tsdata->client, 4,
0302                     wrbuf, 0, NULL);
0303 
0304     case EDT_M09:
0305     case EDT_M12:
0306     case EV_FT:
0307     case GENERIC_FT:
0308         wrbuf[0] = addr;
0309         wrbuf[1] = value;
0310 
0311         return edt_ft5x06_ts_readwrite(tsdata->client, 2,
0312                     wrbuf, 0, NULL);
0313 
0314     default:
0315         return -EINVAL;
0316     }
0317 }
0318 
0319 static int edt_ft5x06_register_read(struct edt_ft5x06_ts_data *tsdata,
0320                     u8 addr)
0321 {
0322     u8 wrbuf[2], rdbuf[2];
0323     int error;
0324 
0325     switch (tsdata->version) {
0326     case EDT_M06:
0327         wrbuf[0] = tsdata->factory_mode ? 0xf3 : 0xfc;
0328         wrbuf[1] = tsdata->factory_mode ? addr & 0x7f : addr & 0x3f;
0329         wrbuf[1] |= tsdata->factory_mode ? 0x80 : 0x40;
0330 
0331         error = edt_ft5x06_ts_readwrite(tsdata->client, 2, wrbuf, 2,
0332                         rdbuf);
0333         if (error)
0334             return error;
0335 
0336         if ((wrbuf[0] ^ wrbuf[1] ^ rdbuf[0]) != rdbuf[1]) {
0337             dev_err(&tsdata->client->dev,
0338                 "crc error: 0x%02x expected, got 0x%02x\n",
0339                 wrbuf[0] ^ wrbuf[1] ^ rdbuf[0],
0340                 rdbuf[1]);
0341             return -EIO;
0342         }
0343         break;
0344 
0345     case EDT_M09:
0346     case EDT_M12:
0347     case EV_FT:
0348     case GENERIC_FT:
0349         wrbuf[0] = addr;
0350         error = edt_ft5x06_ts_readwrite(tsdata->client, 1,
0351                         wrbuf, 1, rdbuf);
0352         if (error)
0353             return error;
0354         break;
0355 
0356     default:
0357         return -EINVAL;
0358     }
0359 
0360     return rdbuf[0];
0361 }
0362 
0363 struct edt_ft5x06_attribute {
0364     struct device_attribute dattr;
0365     size_t field_offset;
0366     u8 limit_low;
0367     u8 limit_high;
0368     u8 addr_m06;
0369     u8 addr_m09;
0370     u8 addr_ev;
0371 };
0372 
0373 #define EDT_ATTR(_field, _mode, _addr_m06, _addr_m09, _addr_ev,     \
0374         _limit_low, _limit_high)                \
0375     struct edt_ft5x06_attribute edt_ft5x06_attr_##_field = {    \
0376         .dattr = __ATTR(_field, _mode,              \
0377                 edt_ft5x06_setting_show,        \
0378                 edt_ft5x06_setting_store),      \
0379         .field_offset = offsetof(struct edt_ft5x06_ts_data, _field), \
0380         .addr_m06 = _addr_m06,                  \
0381         .addr_m09 = _addr_m09,                  \
0382         .addr_ev  = _addr_ev,                   \
0383         .limit_low = _limit_low,                \
0384         .limit_high = _limit_high,              \
0385     }
0386 
0387 static ssize_t edt_ft5x06_setting_show(struct device *dev,
0388                        struct device_attribute *dattr,
0389                        char *buf)
0390 {
0391     struct i2c_client *client = to_i2c_client(dev);
0392     struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
0393     struct edt_ft5x06_attribute *attr =
0394             container_of(dattr, struct edt_ft5x06_attribute, dattr);
0395     u8 *field = (u8 *)tsdata + attr->field_offset;
0396     int val;
0397     size_t count = 0;
0398     int error = 0;
0399     u8 addr;
0400 
0401     mutex_lock(&tsdata->mutex);
0402 
0403     if (tsdata->factory_mode) {
0404         error = -EIO;
0405         goto out;
0406     }
0407 
0408     switch (tsdata->version) {
0409     case EDT_M06:
0410         addr = attr->addr_m06;
0411         break;
0412 
0413     case EDT_M09:
0414     case EDT_M12:
0415     case GENERIC_FT:
0416         addr = attr->addr_m09;
0417         break;
0418 
0419     case EV_FT:
0420         addr = attr->addr_ev;
0421         break;
0422 
0423     default:
0424         error = -ENODEV;
0425         goto out;
0426     }
0427 
0428     if (addr != NO_REGISTER) {
0429         val = edt_ft5x06_register_read(tsdata, addr);
0430         if (val < 0) {
0431             error = val;
0432             dev_err(&tsdata->client->dev,
0433                 "Failed to fetch attribute %s, error %d\n",
0434                 dattr->attr.name, error);
0435             goto out;
0436         }
0437     } else {
0438         val = *field;
0439     }
0440 
0441     if (val != *field) {
0442         dev_warn(&tsdata->client->dev,
0443              "%s: read (%d) and stored value (%d) differ\n",
0444              dattr->attr.name, val, *field);
0445         *field = val;
0446     }
0447 
0448     count = scnprintf(buf, PAGE_SIZE, "%d\n", val);
0449 out:
0450     mutex_unlock(&tsdata->mutex);
0451     return error ?: count;
0452 }
0453 
0454 static ssize_t edt_ft5x06_setting_store(struct device *dev,
0455                     struct device_attribute *dattr,
0456                     const char *buf, size_t count)
0457 {
0458     struct i2c_client *client = to_i2c_client(dev);
0459     struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
0460     struct edt_ft5x06_attribute *attr =
0461             container_of(dattr, struct edt_ft5x06_attribute, dattr);
0462     u8 *field = (u8 *)tsdata + attr->field_offset;
0463     unsigned int val;
0464     int error;
0465     u8 addr;
0466 
0467     mutex_lock(&tsdata->mutex);
0468 
0469     if (tsdata->factory_mode) {
0470         error = -EIO;
0471         goto out;
0472     }
0473 
0474     error = kstrtouint(buf, 0, &val);
0475     if (error)
0476         goto out;
0477 
0478     if (val < attr->limit_low || val > attr->limit_high) {
0479         error = -ERANGE;
0480         goto out;
0481     }
0482 
0483     switch (tsdata->version) {
0484     case EDT_M06:
0485         addr = attr->addr_m06;
0486         break;
0487 
0488     case EDT_M09:
0489     case EDT_M12:
0490     case GENERIC_FT:
0491         addr = attr->addr_m09;
0492         break;
0493 
0494     case EV_FT:
0495         addr = attr->addr_ev;
0496         break;
0497 
0498     default:
0499         error = -ENODEV;
0500         goto out;
0501     }
0502 
0503     if (addr != NO_REGISTER) {
0504         error = edt_ft5x06_register_write(tsdata, addr, val);
0505         if (error) {
0506             dev_err(&tsdata->client->dev,
0507                 "Failed to update attribute %s, error: %d\n",
0508                 dattr->attr.name, error);
0509             goto out;
0510         }
0511     }
0512     *field = val;
0513 
0514 out:
0515     mutex_unlock(&tsdata->mutex);
0516     return error ?: count;
0517 }
0518 
0519 /* m06, m09: range 0-31, m12: range 0-5 */
0520 static EDT_ATTR(gain, S_IWUSR | S_IRUGO, WORK_REGISTER_GAIN,
0521         M09_REGISTER_GAIN, EV_REGISTER_GAIN, 0, 31);
0522 /* m06, m09: range 0-31, m12: range 0-16 */
0523 static EDT_ATTR(offset, S_IWUSR | S_IRUGO, WORK_REGISTER_OFFSET,
0524         M09_REGISTER_OFFSET, NO_REGISTER, 0, 31);
0525 /* m06, m09, m12: no supported, ev_ft: range 0-80 */
0526 static EDT_ATTR(offset_x, S_IWUSR | S_IRUGO, NO_REGISTER, NO_REGISTER,
0527         EV_REGISTER_OFFSET_X, 0, 80);
0528 /* m06, m09, m12: no supported, ev_ft: range 0-80 */
0529 static EDT_ATTR(offset_y, S_IWUSR | S_IRUGO, NO_REGISTER, NO_REGISTER,
0530         EV_REGISTER_OFFSET_Y, 0, 80);
0531 /* m06: range 20 to 80, m09: range 0 to 30, m12: range 1 to 255... */
0532 static EDT_ATTR(threshold, S_IWUSR | S_IRUGO, WORK_REGISTER_THRESHOLD,
0533         M09_REGISTER_THRESHOLD, EV_REGISTER_THRESHOLD, 0, 255);
0534 /* m06: range 3 to 14, m12: range 1 to 255 */
0535 static EDT_ATTR(report_rate, S_IWUSR | S_IRUGO, WORK_REGISTER_REPORT_RATE,
0536         M12_REGISTER_REPORT_RATE, NO_REGISTER, 0, 255);
0537 
0538 static ssize_t model_show(struct device *dev, struct device_attribute *attr,
0539               char *buf)
0540 {
0541     struct i2c_client *client = to_i2c_client(dev);
0542     struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
0543 
0544     return sysfs_emit(buf, "%s\n", tsdata->name);
0545 }
0546 
0547 static DEVICE_ATTR_RO(model);
0548 
0549 static ssize_t fw_version_show(struct device *dev,
0550                    struct device_attribute *attr, char *buf)
0551 {
0552     struct i2c_client *client = to_i2c_client(dev);
0553     struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
0554 
0555     return sysfs_emit(buf, "%s\n", tsdata->fw_version);
0556 }
0557 
0558 static DEVICE_ATTR_RO(fw_version);
0559 
0560 /* m06 only */
0561 static ssize_t header_errors_show(struct device *dev,
0562                   struct device_attribute *attr, char *buf)
0563 {
0564     struct i2c_client *client = to_i2c_client(dev);
0565     struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
0566 
0567     return sysfs_emit(buf, "%d\n", tsdata->header_errors);
0568 }
0569 
0570 static DEVICE_ATTR_RO(header_errors);
0571 
0572 /* m06 only */
0573 static ssize_t crc_errors_show(struct device *dev,
0574                    struct device_attribute *attr, char *buf)
0575 {
0576     struct i2c_client *client = to_i2c_client(dev);
0577     struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
0578 
0579     return sysfs_emit(buf, "%d\n", tsdata->crc_errors);
0580 }
0581 
0582 static DEVICE_ATTR_RO(crc_errors);
0583 
0584 static struct attribute *edt_ft5x06_attrs[] = {
0585     &edt_ft5x06_attr_gain.dattr.attr,
0586     &edt_ft5x06_attr_offset.dattr.attr,
0587     &edt_ft5x06_attr_offset_x.dattr.attr,
0588     &edt_ft5x06_attr_offset_y.dattr.attr,
0589     &edt_ft5x06_attr_threshold.dattr.attr,
0590     &edt_ft5x06_attr_report_rate.dattr.attr,
0591     &dev_attr_model.attr,
0592     &dev_attr_fw_version.attr,
0593     &dev_attr_header_errors.attr,
0594     &dev_attr_crc_errors.attr,
0595     NULL
0596 };
0597 
0598 static const struct attribute_group edt_ft5x06_attr_group = {
0599     .attrs = edt_ft5x06_attrs,
0600 };
0601 
0602 static void edt_ft5x06_restore_reg_parameters(struct edt_ft5x06_ts_data *tsdata)
0603 {
0604     struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
0605 
0606     edt_ft5x06_register_write(tsdata, reg_addr->reg_threshold,
0607                   tsdata->threshold);
0608     edt_ft5x06_register_write(tsdata, reg_addr->reg_gain,
0609                   tsdata->gain);
0610     if (reg_addr->reg_offset != NO_REGISTER)
0611         edt_ft5x06_register_write(tsdata, reg_addr->reg_offset,
0612                       tsdata->offset);
0613     if (reg_addr->reg_offset_x != NO_REGISTER)
0614         edt_ft5x06_register_write(tsdata, reg_addr->reg_offset_x,
0615                       tsdata->offset_x);
0616     if (reg_addr->reg_offset_y != NO_REGISTER)
0617         edt_ft5x06_register_write(tsdata, reg_addr->reg_offset_y,
0618                       tsdata->offset_y);
0619     if (reg_addr->reg_report_rate != NO_REGISTER)
0620         edt_ft5x06_register_write(tsdata, reg_addr->reg_report_rate,
0621                   tsdata->report_rate);
0622 
0623 }
0624 
0625 #ifdef CONFIG_DEBUG_FS
0626 static int edt_ft5x06_factory_mode(struct edt_ft5x06_ts_data *tsdata)
0627 {
0628     struct i2c_client *client = tsdata->client;
0629     int retries = EDT_SWITCH_MODE_RETRIES;
0630     int ret;
0631     int error;
0632 
0633     if (tsdata->version != EDT_M06) {
0634         dev_err(&client->dev,
0635             "No factory mode support for non-M06 devices\n");
0636         return -EINVAL;
0637     }
0638 
0639     disable_irq(client->irq);
0640 
0641     if (!tsdata->raw_buffer) {
0642         tsdata->raw_bufsize = tsdata->num_x * tsdata->num_y *
0643                       sizeof(u16);
0644         tsdata->raw_buffer = kzalloc(tsdata->raw_bufsize, GFP_KERNEL);
0645         if (!tsdata->raw_buffer) {
0646             error = -ENOMEM;
0647             goto err_out;
0648         }
0649     }
0650 
0651     /* mode register is 0x3c when in the work mode */
0652     error = edt_ft5x06_register_write(tsdata, WORK_REGISTER_OPMODE, 0x03);
0653     if (error) {
0654         dev_err(&client->dev,
0655             "failed to switch to factory mode, error %d\n", error);
0656         goto err_out;
0657     }
0658 
0659     tsdata->factory_mode = true;
0660     do {
0661         mdelay(EDT_SWITCH_MODE_DELAY);
0662         /* mode register is 0x01 when in factory mode */
0663         ret = edt_ft5x06_register_read(tsdata, FACTORY_REGISTER_OPMODE);
0664         if (ret == 0x03)
0665             break;
0666     } while (--retries > 0);
0667 
0668     if (retries == 0) {
0669         dev_err(&client->dev, "not in factory mode after %dms.\n",
0670             EDT_SWITCH_MODE_RETRIES * EDT_SWITCH_MODE_DELAY);
0671         error = -EIO;
0672         goto err_out;
0673     }
0674 
0675     return 0;
0676 
0677 err_out:
0678     kfree(tsdata->raw_buffer);
0679     tsdata->raw_buffer = NULL;
0680     tsdata->factory_mode = false;
0681     enable_irq(client->irq);
0682 
0683     return error;
0684 }
0685 
0686 static int edt_ft5x06_work_mode(struct edt_ft5x06_ts_data *tsdata)
0687 {
0688     struct i2c_client *client = tsdata->client;
0689     int retries = EDT_SWITCH_MODE_RETRIES;
0690     int ret;
0691     int error;
0692 
0693     /* mode register is 0x01 when in the factory mode */
0694     error = edt_ft5x06_register_write(tsdata, FACTORY_REGISTER_OPMODE, 0x1);
0695     if (error) {
0696         dev_err(&client->dev,
0697             "failed to switch to work mode, error: %d\n", error);
0698         return error;
0699     }
0700 
0701     tsdata->factory_mode = false;
0702 
0703     do {
0704         mdelay(EDT_SWITCH_MODE_DELAY);
0705         /* mode register is 0x01 when in factory mode */
0706         ret = edt_ft5x06_register_read(tsdata, WORK_REGISTER_OPMODE);
0707         if (ret == 0x01)
0708             break;
0709     } while (--retries > 0);
0710 
0711     if (retries == 0) {
0712         dev_err(&client->dev, "not in work mode after %dms.\n",
0713             EDT_SWITCH_MODE_RETRIES * EDT_SWITCH_MODE_DELAY);
0714         tsdata->factory_mode = true;
0715         return -EIO;
0716     }
0717 
0718     kfree(tsdata->raw_buffer);
0719     tsdata->raw_buffer = NULL;
0720 
0721     edt_ft5x06_restore_reg_parameters(tsdata);
0722     enable_irq(client->irq);
0723 
0724     return 0;
0725 }
0726 
0727 static int edt_ft5x06_debugfs_mode_get(void *data, u64 *mode)
0728 {
0729     struct edt_ft5x06_ts_data *tsdata = data;
0730 
0731     *mode = tsdata->factory_mode;
0732 
0733     return 0;
0734 };
0735 
0736 static int edt_ft5x06_debugfs_mode_set(void *data, u64 mode)
0737 {
0738     struct edt_ft5x06_ts_data *tsdata = data;
0739     int retval = 0;
0740 
0741     if (mode > 1)
0742         return -ERANGE;
0743 
0744     mutex_lock(&tsdata->mutex);
0745 
0746     if (mode != tsdata->factory_mode) {
0747         retval = mode ? edt_ft5x06_factory_mode(tsdata) :
0748                 edt_ft5x06_work_mode(tsdata);
0749     }
0750 
0751     mutex_unlock(&tsdata->mutex);
0752 
0753     return retval;
0754 };
0755 
0756 DEFINE_SIMPLE_ATTRIBUTE(debugfs_mode_fops, edt_ft5x06_debugfs_mode_get,
0757             edt_ft5x06_debugfs_mode_set, "%llu\n");
0758 
0759 static ssize_t edt_ft5x06_debugfs_raw_data_read(struct file *file,
0760                 char __user *buf, size_t count, loff_t *off)
0761 {
0762     struct edt_ft5x06_ts_data *tsdata = file->private_data;
0763     struct i2c_client *client = tsdata->client;
0764     int retries  = EDT_RAW_DATA_RETRIES;
0765     int val, i, error;
0766     size_t read = 0;
0767     int colbytes;
0768     char wrbuf[3];
0769     u8 *rdbuf;
0770 
0771     if (*off < 0 || *off >= tsdata->raw_bufsize)
0772         return 0;
0773 
0774     mutex_lock(&tsdata->mutex);
0775 
0776     if (!tsdata->factory_mode || !tsdata->raw_buffer) {
0777         error = -EIO;
0778         goto out;
0779     }
0780 
0781     error = edt_ft5x06_register_write(tsdata, 0x08, 0x01);
0782     if (error) {
0783         dev_dbg(&client->dev,
0784             "failed to write 0x08 register, error %d\n", error);
0785         goto out;
0786     }
0787 
0788     do {
0789         usleep_range(EDT_RAW_DATA_DELAY, EDT_RAW_DATA_DELAY + 100);
0790         val = edt_ft5x06_register_read(tsdata, 0x08);
0791         if (val < 1)
0792             break;
0793     } while (--retries > 0);
0794 
0795     if (val < 0) {
0796         error = val;
0797         dev_dbg(&client->dev,
0798             "failed to read 0x08 register, error %d\n", error);
0799         goto out;
0800     }
0801 
0802     if (retries == 0) {
0803         dev_dbg(&client->dev,
0804             "timed out waiting for register to settle\n");
0805         error = -ETIMEDOUT;
0806         goto out;
0807     }
0808 
0809     rdbuf = tsdata->raw_buffer;
0810     colbytes = tsdata->num_y * sizeof(u16);
0811 
0812     wrbuf[0] = 0xf5;
0813     wrbuf[1] = 0x0e;
0814     for (i = 0; i < tsdata->num_x; i++) {
0815         wrbuf[2] = i;  /* column index */
0816         error = edt_ft5x06_ts_readwrite(tsdata->client,
0817                         sizeof(wrbuf), wrbuf,
0818                         colbytes, rdbuf);
0819         if (error)
0820             goto out;
0821 
0822         rdbuf += colbytes;
0823     }
0824 
0825     read = min_t(size_t, count, tsdata->raw_bufsize - *off);
0826     if (copy_to_user(buf, tsdata->raw_buffer + *off, read)) {
0827         error = -EFAULT;
0828         goto out;
0829     }
0830 
0831     *off += read;
0832 out:
0833     mutex_unlock(&tsdata->mutex);
0834     return error ?: read;
0835 };
0836 
0837 static const struct file_operations debugfs_raw_data_fops = {
0838     .open = simple_open,
0839     .read = edt_ft5x06_debugfs_raw_data_read,
0840 };
0841 
0842 static void edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata,
0843                       const char *debugfs_name)
0844 {
0845     tsdata->debug_dir = debugfs_create_dir(debugfs_name, NULL);
0846 
0847     debugfs_create_u16("num_x", S_IRUSR, tsdata->debug_dir, &tsdata->num_x);
0848     debugfs_create_u16("num_y", S_IRUSR, tsdata->debug_dir, &tsdata->num_y);
0849 
0850     debugfs_create_file("mode", S_IRUSR | S_IWUSR,
0851                 tsdata->debug_dir, tsdata, &debugfs_mode_fops);
0852     debugfs_create_file("raw_data", S_IRUSR,
0853                 tsdata->debug_dir, tsdata, &debugfs_raw_data_fops);
0854 }
0855 
0856 static void edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata)
0857 {
0858     debugfs_remove_recursive(tsdata->debug_dir);
0859     kfree(tsdata->raw_buffer);
0860 }
0861 
0862 #else
0863 
0864 static int edt_ft5x06_factory_mode(struct edt_ft5x06_ts_data *tsdata)
0865 {
0866     return -ENOSYS;
0867 }
0868 
0869 static void edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata,
0870                       const char *debugfs_name)
0871 {
0872 }
0873 
0874 static void edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata)
0875 {
0876 }
0877 
0878 #endif /* CONFIG_DEBUGFS */
0879 
0880 static int edt_ft5x06_ts_identify(struct i2c_client *client,
0881                   struct edt_ft5x06_ts_data *tsdata)
0882 {
0883     u8 rdbuf[EDT_NAME_LEN];
0884     char *p;
0885     int error;
0886     char *model_name = tsdata->name;
0887     char *fw_version = tsdata->fw_version;
0888 
0889     /* see what we find if we assume it is a M06 *
0890      * if we get less than EDT_NAME_LEN, we don't want
0891      * to have garbage in there
0892      */
0893     memset(rdbuf, 0, sizeof(rdbuf));
0894     error = edt_ft5x06_ts_readwrite(client, 1, "\xBB",
0895                     EDT_NAME_LEN - 1, rdbuf);
0896     if (error)
0897         return error;
0898 
0899     /* Probe content for something consistent.
0900      * M06 starts with a response byte, M12 gives the data directly.
0901      * M09/Generic does not provide model number information.
0902      */
0903     if (!strncasecmp(rdbuf + 1, "EP0", 3)) {
0904         tsdata->version = EDT_M06;
0905 
0906         /* remove last '$' end marker */
0907         rdbuf[EDT_NAME_LEN - 1] = '\0';
0908         if (rdbuf[EDT_NAME_LEN - 2] == '$')
0909             rdbuf[EDT_NAME_LEN - 2] = '\0';
0910 
0911         /* look for Model/Version separator */
0912         p = strchr(rdbuf, '*');
0913         if (p)
0914             *p++ = '\0';
0915         strlcpy(model_name, rdbuf + 1, EDT_NAME_LEN);
0916         strlcpy(fw_version, p ? p : "", EDT_NAME_LEN);
0917     } else if (!strncasecmp(rdbuf, "EP0", 3)) {
0918         tsdata->version = EDT_M12;
0919 
0920         /* remove last '$' end marker */
0921         rdbuf[EDT_NAME_LEN - 2] = '\0';
0922         if (rdbuf[EDT_NAME_LEN - 3] == '$')
0923             rdbuf[EDT_NAME_LEN - 3] = '\0';
0924 
0925         /* look for Model/Version separator */
0926         p = strchr(rdbuf, '*');
0927         if (p)
0928             *p++ = '\0';
0929         strlcpy(model_name, rdbuf, EDT_NAME_LEN);
0930         strlcpy(fw_version, p ? p : "", EDT_NAME_LEN);
0931     } else {
0932         /* If it is not an EDT M06/M12 touchscreen, then the model
0933          * detection is a bit hairy. The different ft5x06
0934          * firmares around don't reliably implement the
0935          * identification registers. Well, we'll take a shot.
0936          *
0937          * The main difference between generic focaltec based
0938          * touches and EDT M09 is that we know how to retrieve
0939          * the max coordinates for the latter.
0940          */
0941         tsdata->version = GENERIC_FT;
0942 
0943         error = edt_ft5x06_ts_readwrite(client, 1, "\xA6",
0944                         2, rdbuf);
0945         if (error)
0946             return error;
0947 
0948         strlcpy(fw_version, rdbuf, 2);
0949 
0950         error = edt_ft5x06_ts_readwrite(client, 1, "\xA8",
0951                         1, rdbuf);
0952         if (error)
0953             return error;
0954 
0955         /* This "model identification" is not exact. Unfortunately
0956          * not all firmwares for the ft5x06 put useful values in
0957          * the identification registers.
0958          */
0959         switch (rdbuf[0]) {
0960         case 0x11:   /* EDT EP0110M09 */
0961         case 0x35:   /* EDT EP0350M09 */
0962         case 0x43:   /* EDT EP0430M09 */
0963         case 0x50:   /* EDT EP0500M09 */
0964         case 0x57:   /* EDT EP0570M09 */
0965         case 0x70:   /* EDT EP0700M09 */
0966             tsdata->version = EDT_M09;
0967             snprintf(model_name, EDT_NAME_LEN, "EP0%i%i0M09",
0968                 rdbuf[0] >> 4, rdbuf[0] & 0x0F);
0969             break;
0970         case 0xa1:   /* EDT EP1010ML00 */
0971             tsdata->version = EDT_M09;
0972             snprintf(model_name, EDT_NAME_LEN, "EP%i%i0ML00",
0973                 rdbuf[0] >> 4, rdbuf[0] & 0x0F);
0974             break;
0975         case 0x5a:   /* Solomon Goldentek Display */
0976             snprintf(model_name, EDT_NAME_LEN, "GKTW50SCED1R0");
0977             break;
0978         case 0x59:  /* Evervision Display with FT5xx6 TS */
0979             tsdata->version = EV_FT;
0980             error = edt_ft5x06_ts_readwrite(client, 1, "\x53",
0981                             1, rdbuf);
0982             if (error)
0983                 return error;
0984             strlcpy(fw_version, rdbuf, 1);
0985             snprintf(model_name, EDT_NAME_LEN,
0986                  "EVERVISION-FT5726NEi");
0987             break;
0988         default:
0989             snprintf(model_name, EDT_NAME_LEN,
0990                  "generic ft5x06 (%02x)",
0991                  rdbuf[0]);
0992             break;
0993         }
0994     }
0995 
0996     return 0;
0997 }
0998 
0999 static void edt_ft5x06_ts_get_defaults(struct device *dev,
1000                        struct edt_ft5x06_ts_data *tsdata)
1001 {
1002     struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
1003     u32 val;
1004     int error;
1005 
1006     error = device_property_read_u32(dev, "threshold", &val);
1007     if (!error) {
1008         edt_ft5x06_register_write(tsdata, reg_addr->reg_threshold, val);
1009         tsdata->threshold = val;
1010     }
1011 
1012     error = device_property_read_u32(dev, "gain", &val);
1013     if (!error) {
1014         edt_ft5x06_register_write(tsdata, reg_addr->reg_gain, val);
1015         tsdata->gain = val;
1016     }
1017 
1018     error = device_property_read_u32(dev, "offset", &val);
1019     if (!error) {
1020         if (reg_addr->reg_offset != NO_REGISTER)
1021             edt_ft5x06_register_write(tsdata,
1022                           reg_addr->reg_offset, val);
1023         tsdata->offset = val;
1024     }
1025 
1026     error = device_property_read_u32(dev, "offset-x", &val);
1027     if (!error) {
1028         if (reg_addr->reg_offset_x != NO_REGISTER)
1029             edt_ft5x06_register_write(tsdata,
1030                           reg_addr->reg_offset_x, val);
1031         tsdata->offset_x = val;
1032     }
1033 
1034     error = device_property_read_u32(dev, "offset-y", &val);
1035     if (!error) {
1036         if (reg_addr->reg_offset_y != NO_REGISTER)
1037             edt_ft5x06_register_write(tsdata,
1038                           reg_addr->reg_offset_y, val);
1039         tsdata->offset_y = val;
1040     }
1041 }
1042 
1043 static void edt_ft5x06_ts_get_parameters(struct edt_ft5x06_ts_data *tsdata)
1044 {
1045     struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
1046 
1047     tsdata->threshold = edt_ft5x06_register_read(tsdata,
1048                              reg_addr->reg_threshold);
1049     tsdata->gain = edt_ft5x06_register_read(tsdata, reg_addr->reg_gain);
1050     if (reg_addr->reg_offset != NO_REGISTER)
1051         tsdata->offset =
1052             edt_ft5x06_register_read(tsdata, reg_addr->reg_offset);
1053     if (reg_addr->reg_offset_x != NO_REGISTER)
1054         tsdata->offset_x = edt_ft5x06_register_read(tsdata,
1055                         reg_addr->reg_offset_x);
1056     if (reg_addr->reg_offset_y != NO_REGISTER)
1057         tsdata->offset_y = edt_ft5x06_register_read(tsdata,
1058                         reg_addr->reg_offset_y);
1059     if (reg_addr->reg_report_rate != NO_REGISTER)
1060         tsdata->report_rate = edt_ft5x06_register_read(tsdata,
1061                         reg_addr->reg_report_rate);
1062     tsdata->num_x = EDT_DEFAULT_NUM_X;
1063     if (reg_addr->reg_num_x != NO_REGISTER)
1064         tsdata->num_x = edt_ft5x06_register_read(tsdata,
1065                              reg_addr->reg_num_x);
1066     tsdata->num_y = EDT_DEFAULT_NUM_Y;
1067     if (reg_addr->reg_num_y != NO_REGISTER)
1068         tsdata->num_y = edt_ft5x06_register_read(tsdata,
1069                              reg_addr->reg_num_y);
1070 }
1071 
1072 static void edt_ft5x06_ts_set_regs(struct edt_ft5x06_ts_data *tsdata)
1073 {
1074     struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
1075 
1076     switch (tsdata->version) {
1077     case EDT_M06:
1078         reg_addr->reg_threshold = WORK_REGISTER_THRESHOLD;
1079         reg_addr->reg_report_rate = WORK_REGISTER_REPORT_RATE;
1080         reg_addr->reg_gain = WORK_REGISTER_GAIN;
1081         reg_addr->reg_offset = WORK_REGISTER_OFFSET;
1082         reg_addr->reg_offset_x = NO_REGISTER;
1083         reg_addr->reg_offset_y = NO_REGISTER;
1084         reg_addr->reg_num_x = WORK_REGISTER_NUM_X;
1085         reg_addr->reg_num_y = WORK_REGISTER_NUM_Y;
1086         break;
1087 
1088     case EDT_M09:
1089     case EDT_M12:
1090         reg_addr->reg_threshold = M09_REGISTER_THRESHOLD;
1091         reg_addr->reg_report_rate = tsdata->version == EDT_M12 ?
1092             M12_REGISTER_REPORT_RATE : NO_REGISTER;
1093         reg_addr->reg_gain = M09_REGISTER_GAIN;
1094         reg_addr->reg_offset = M09_REGISTER_OFFSET;
1095         reg_addr->reg_offset_x = NO_REGISTER;
1096         reg_addr->reg_offset_y = NO_REGISTER;
1097         reg_addr->reg_num_x = M09_REGISTER_NUM_X;
1098         reg_addr->reg_num_y = M09_REGISTER_NUM_Y;
1099         break;
1100 
1101     case EV_FT:
1102         reg_addr->reg_threshold = EV_REGISTER_THRESHOLD;
1103         reg_addr->reg_report_rate = NO_REGISTER;
1104         reg_addr->reg_gain = EV_REGISTER_GAIN;
1105         reg_addr->reg_offset = NO_REGISTER;
1106         reg_addr->reg_offset_x = EV_REGISTER_OFFSET_X;
1107         reg_addr->reg_offset_y = EV_REGISTER_OFFSET_Y;
1108         reg_addr->reg_num_x = NO_REGISTER;
1109         reg_addr->reg_num_y = NO_REGISTER;
1110         break;
1111 
1112     case GENERIC_FT:
1113         /* this is a guesswork */
1114         reg_addr->reg_threshold = M09_REGISTER_THRESHOLD;
1115         reg_addr->reg_report_rate = NO_REGISTER;
1116         reg_addr->reg_gain = M09_REGISTER_GAIN;
1117         reg_addr->reg_offset = M09_REGISTER_OFFSET;
1118         reg_addr->reg_offset_x = NO_REGISTER;
1119         reg_addr->reg_offset_y = NO_REGISTER;
1120         reg_addr->reg_num_x = NO_REGISTER;
1121         reg_addr->reg_num_y = NO_REGISTER;
1122         break;
1123     }
1124 }
1125 
1126 static void edt_ft5x06_disable_regulators(void *arg)
1127 {
1128     struct edt_ft5x06_ts_data *data = arg;
1129 
1130     regulator_disable(data->vcc);
1131     regulator_disable(data->iovcc);
1132 }
1133 
1134 static int edt_ft5x06_ts_probe(struct i2c_client *client,
1135                      const struct i2c_device_id *id)
1136 {
1137     const struct edt_i2c_chip_data *chip_data;
1138     struct edt_ft5x06_ts_data *tsdata;
1139     u8 buf[2] = { 0xfc, 0x00 };
1140     struct input_dev *input;
1141     unsigned long irq_flags;
1142     int error;
1143     u32 report_rate;
1144 
1145     dev_dbg(&client->dev, "probing for EDT FT5x06 I2C\n");
1146 
1147     tsdata = devm_kzalloc(&client->dev, sizeof(*tsdata), GFP_KERNEL);
1148     if (!tsdata) {
1149         dev_err(&client->dev, "failed to allocate driver data.\n");
1150         return -ENOMEM;
1151     }
1152 
1153     chip_data = device_get_match_data(&client->dev);
1154     if (!chip_data)
1155         chip_data = (const struct edt_i2c_chip_data *)id->driver_data;
1156     if (!chip_data || !chip_data->max_support_points) {
1157         dev_err(&client->dev, "invalid or missing chip data\n");
1158         return -EINVAL;
1159     }
1160 
1161     tsdata->max_support_points = chip_data->max_support_points;
1162 
1163     tsdata->vcc = devm_regulator_get(&client->dev, "vcc");
1164     if (IS_ERR(tsdata->vcc)) {
1165         error = PTR_ERR(tsdata->vcc);
1166         if (error != -EPROBE_DEFER)
1167             dev_err(&client->dev,
1168                 "failed to request regulator: %d\n", error);
1169         return error;
1170     }
1171 
1172     tsdata->iovcc = devm_regulator_get(&client->dev, "iovcc");
1173     if (IS_ERR(tsdata->iovcc)) {
1174         error = PTR_ERR(tsdata->iovcc);
1175         if (error != -EPROBE_DEFER)
1176             dev_err(&client->dev,
1177                 "failed to request iovcc regulator: %d\n", error);
1178         return error;
1179     }
1180 
1181     error = regulator_enable(tsdata->iovcc);
1182     if (error < 0) {
1183         dev_err(&client->dev, "failed to enable iovcc: %d\n", error);
1184         return error;
1185     }
1186 
1187     /* Delay enabling VCC for > 10us (T_ivd) after IOVCC */
1188     usleep_range(10, 100);
1189 
1190     error = regulator_enable(tsdata->vcc);
1191     if (error < 0) {
1192         dev_err(&client->dev, "failed to enable vcc: %d\n", error);
1193         regulator_disable(tsdata->iovcc);
1194         return error;
1195     }
1196 
1197     error = devm_add_action_or_reset(&client->dev,
1198                      edt_ft5x06_disable_regulators,
1199                      tsdata);
1200     if (error)
1201         return error;
1202 
1203     tsdata->reset_gpio = devm_gpiod_get_optional(&client->dev,
1204                              "reset", GPIOD_OUT_HIGH);
1205     if (IS_ERR(tsdata->reset_gpio)) {
1206         error = PTR_ERR(tsdata->reset_gpio);
1207         dev_err(&client->dev,
1208             "Failed to request GPIO reset pin, error %d\n", error);
1209         return error;
1210     }
1211 
1212     tsdata->wake_gpio = devm_gpiod_get_optional(&client->dev,
1213                             "wake", GPIOD_OUT_LOW);
1214     if (IS_ERR(tsdata->wake_gpio)) {
1215         error = PTR_ERR(tsdata->wake_gpio);
1216         dev_err(&client->dev,
1217             "Failed to request GPIO wake pin, error %d\n", error);
1218         return error;
1219     }
1220 
1221     /*
1222      * Check which sleep modes we can support. Power-off requieres the
1223      * reset-pin to ensure correct power-down/power-up behaviour. Start with
1224      * the EDT_PMODE_POWEROFF test since this is the deepest possible sleep
1225      * mode.
1226      */
1227     if (tsdata->reset_gpio)
1228         tsdata->suspend_mode = EDT_PMODE_POWEROFF;
1229     else if (tsdata->wake_gpio)
1230         tsdata->suspend_mode = EDT_PMODE_HIBERNATE;
1231     else
1232         tsdata->suspend_mode = EDT_PMODE_NOT_SUPPORTED;
1233 
1234     if (tsdata->wake_gpio) {
1235         usleep_range(5000, 6000);
1236         gpiod_set_value_cansleep(tsdata->wake_gpio, 1);
1237     }
1238 
1239     if (tsdata->reset_gpio) {
1240         usleep_range(5000, 6000);
1241         gpiod_set_value_cansleep(tsdata->reset_gpio, 0);
1242         msleep(300);
1243     }
1244 
1245     input = devm_input_allocate_device(&client->dev);
1246     if (!input) {
1247         dev_err(&client->dev, "failed to allocate input device.\n");
1248         return -ENOMEM;
1249     }
1250 
1251     mutex_init(&tsdata->mutex);
1252     tsdata->client = client;
1253     tsdata->input = input;
1254     tsdata->factory_mode = false;
1255 
1256     error = edt_ft5x06_ts_identify(client, tsdata);
1257     if (error) {
1258         dev_err(&client->dev, "touchscreen probe failed\n");
1259         return error;
1260     }
1261 
1262     /*
1263      * Dummy read access. EP0700MLP1 returns bogus data on the first
1264      * register read access and ignores writes.
1265      */
1266     edt_ft5x06_ts_readwrite(tsdata->client, 2, buf, 2, buf);
1267 
1268     edt_ft5x06_ts_set_regs(tsdata);
1269     edt_ft5x06_ts_get_defaults(&client->dev, tsdata);
1270     edt_ft5x06_ts_get_parameters(tsdata);
1271 
1272     if (tsdata->reg_addr.reg_report_rate != NO_REGISTER &&
1273         !device_property_read_u32(&client->dev,
1274                       "report-rate-hz", &report_rate)) {
1275         if (tsdata->version == EDT_M06)
1276             tsdata->report_rate = clamp_val(report_rate, 30, 140);
1277         else
1278             tsdata->report_rate = clamp_val(report_rate, 1, 255);
1279 
1280         if (report_rate != tsdata->report_rate)
1281             dev_warn(&client->dev,
1282                  "report-rate %dHz is unsupported, use %dHz\n",
1283                  report_rate, tsdata->report_rate);
1284 
1285         if (tsdata->version == EDT_M06)
1286             tsdata->report_rate /= 10;
1287 
1288         edt_ft5x06_register_write(tsdata,
1289                       tsdata->reg_addr.reg_report_rate,
1290                       tsdata->report_rate);
1291     }
1292 
1293     dev_dbg(&client->dev,
1294         "Model \"%s\", Rev. \"%s\", %dx%d sensors\n",
1295         tsdata->name, tsdata->fw_version, tsdata->num_x, tsdata->num_y);
1296 
1297     input->name = tsdata->name;
1298     input->id.bustype = BUS_I2C;
1299     input->dev.parent = &client->dev;
1300 
1301     input_set_abs_params(input, ABS_MT_POSITION_X,
1302                  0, tsdata->num_x * 64 - 1, 0, 0);
1303     input_set_abs_params(input, ABS_MT_POSITION_Y,
1304                  0, tsdata->num_y * 64 - 1, 0, 0);
1305 
1306     touchscreen_parse_properties(input, true, &tsdata->prop);
1307 
1308     error = input_mt_init_slots(input, tsdata->max_support_points,
1309                 INPUT_MT_DIRECT);
1310     if (error) {
1311         dev_err(&client->dev, "Unable to init MT slots.\n");
1312         return error;
1313     }
1314 
1315     i2c_set_clientdata(client, tsdata);
1316 
1317     irq_flags = irq_get_trigger_type(client->irq);
1318     if (irq_flags == IRQF_TRIGGER_NONE)
1319         irq_flags = IRQF_TRIGGER_FALLING;
1320     irq_flags |= IRQF_ONESHOT;
1321 
1322     error = devm_request_threaded_irq(&client->dev, client->irq,
1323                     NULL, edt_ft5x06_ts_isr, irq_flags,
1324                     client->name, tsdata);
1325     if (error) {
1326         dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
1327         return error;
1328     }
1329 
1330     error = devm_device_add_group(&client->dev, &edt_ft5x06_attr_group);
1331     if (error)
1332         return error;
1333 
1334     error = input_register_device(input);
1335     if (error)
1336         return error;
1337 
1338     edt_ft5x06_ts_prepare_debugfs(tsdata, dev_driver_string(&client->dev));
1339 
1340     dev_dbg(&client->dev,
1341         "EDT FT5x06 initialized: IRQ %d, WAKE pin %d, Reset pin %d.\n",
1342         client->irq,
1343         tsdata->wake_gpio ? desc_to_gpio(tsdata->wake_gpio) : -1,
1344         tsdata->reset_gpio ? desc_to_gpio(tsdata->reset_gpio) : -1);
1345 
1346     return 0;
1347 }
1348 
1349 static int edt_ft5x06_ts_remove(struct i2c_client *client)
1350 {
1351     struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
1352 
1353     edt_ft5x06_ts_teardown_debugfs(tsdata);
1354 
1355     return 0;
1356 }
1357 
1358 static int __maybe_unused edt_ft5x06_ts_suspend(struct device *dev)
1359 {
1360     struct i2c_client *client = to_i2c_client(dev);
1361     struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
1362     struct gpio_desc *reset_gpio = tsdata->reset_gpio;
1363     int ret;
1364 
1365     if (device_may_wakeup(dev))
1366         return 0;
1367 
1368     if (tsdata->suspend_mode == EDT_PMODE_NOT_SUPPORTED)
1369         return 0;
1370 
1371     /* Enter hibernate mode. */
1372     ret = edt_ft5x06_register_write(tsdata, PMOD_REGISTER_OPMODE,
1373                     PMOD_REGISTER_HIBERNATE);
1374     if (ret)
1375         dev_warn(dev, "Failed to set hibernate mode\n");
1376 
1377     if (tsdata->suspend_mode == EDT_PMODE_HIBERNATE)
1378         return 0;
1379 
1380     /*
1381      * Power-off according the datasheet. Cut the power may leaf the irq
1382      * line in an undefined state depending on the host pull resistor
1383      * settings. Disable the irq to avoid adjusting each host till the
1384      * device is back in a full functional state.
1385      */
1386     disable_irq(tsdata->client->irq);
1387 
1388     gpiod_set_value_cansleep(reset_gpio, 1);
1389     usleep_range(1000, 2000);
1390 
1391     ret = regulator_disable(tsdata->vcc);
1392     if (ret)
1393         dev_warn(dev, "Failed to disable vcc\n");
1394     ret = regulator_disable(tsdata->iovcc);
1395     if (ret)
1396         dev_warn(dev, "Failed to disable iovcc\n");
1397 
1398     return 0;
1399 }
1400 
1401 static int __maybe_unused edt_ft5x06_ts_resume(struct device *dev)
1402 {
1403     struct i2c_client *client = to_i2c_client(dev);
1404     struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
1405     int ret = 0;
1406 
1407     if (device_may_wakeup(dev))
1408         return 0;
1409 
1410     if (tsdata->suspend_mode == EDT_PMODE_NOT_SUPPORTED)
1411         return 0;
1412 
1413     if (tsdata->suspend_mode == EDT_PMODE_POWEROFF) {
1414         struct gpio_desc *reset_gpio = tsdata->reset_gpio;
1415 
1416         /*
1417          * We can't check if the regulator is a dummy or a real
1418          * regulator. So we need to specify the 5ms reset time (T_rst)
1419          * here instead of the 100us T_rtp time. We also need to wait
1420          * 300ms in case it was a real supply and the power was cutted
1421          * of. Toggle the reset pin is also a way to exit the hibernate
1422          * mode.
1423          */
1424         gpiod_set_value_cansleep(reset_gpio, 1);
1425         usleep_range(5000, 6000);
1426 
1427         ret = regulator_enable(tsdata->iovcc);
1428         if (ret) {
1429             dev_err(dev, "Failed to enable iovcc\n");
1430             return ret;
1431         }
1432 
1433         /* Delay enabling VCC for > 10us (T_ivd) after IOVCC */
1434         usleep_range(10, 100);
1435 
1436         ret = regulator_enable(tsdata->vcc);
1437         if (ret) {
1438             dev_err(dev, "Failed to enable vcc\n");
1439             regulator_disable(tsdata->iovcc);
1440             return ret;
1441         }
1442 
1443         usleep_range(1000, 2000);
1444         gpiod_set_value_cansleep(reset_gpio, 0);
1445         msleep(300);
1446 
1447         edt_ft5x06_restore_reg_parameters(tsdata);
1448         enable_irq(tsdata->client->irq);
1449 
1450         if (tsdata->factory_mode)
1451             ret = edt_ft5x06_factory_mode(tsdata);
1452     } else {
1453         struct gpio_desc *wake_gpio = tsdata->wake_gpio;
1454 
1455         gpiod_set_value_cansleep(wake_gpio, 0);
1456         usleep_range(5000, 6000);
1457         gpiod_set_value_cansleep(wake_gpio, 1);
1458     }
1459 
1460 
1461     return ret;
1462 }
1463 
1464 static SIMPLE_DEV_PM_OPS(edt_ft5x06_ts_pm_ops,
1465              edt_ft5x06_ts_suspend, edt_ft5x06_ts_resume);
1466 
1467 static const struct edt_i2c_chip_data edt_ft5x06_data = {
1468     .max_support_points = 5,
1469 };
1470 
1471 static const struct edt_i2c_chip_data edt_ft5506_data = {
1472     .max_support_points = 10,
1473 };
1474 
1475 static const struct edt_i2c_chip_data edt_ft6236_data = {
1476     .max_support_points = 2,
1477 };
1478 
1479 static const struct i2c_device_id edt_ft5x06_ts_id[] = {
1480     { .name = "edt-ft5x06", .driver_data = (long)&edt_ft5x06_data },
1481     { .name = "edt-ft5506", .driver_data = (long)&edt_ft5506_data },
1482     { .name = "ev-ft5726", .driver_data = (long)&edt_ft5506_data },
1483     /* Note no edt- prefix for compatibility with the ft6236.c driver */
1484     { .name = "ft6236", .driver_data = (long)&edt_ft6236_data },
1485     { /* sentinel */ }
1486 };
1487 MODULE_DEVICE_TABLE(i2c, edt_ft5x06_ts_id);
1488 
1489 static const struct of_device_id edt_ft5x06_of_match[] = {
1490     { .compatible = "edt,edt-ft5206", .data = &edt_ft5x06_data },
1491     { .compatible = "edt,edt-ft5306", .data = &edt_ft5x06_data },
1492     { .compatible = "edt,edt-ft5406", .data = &edt_ft5x06_data },
1493     { .compatible = "edt,edt-ft5506", .data = &edt_ft5506_data },
1494     { .compatible = "evervision,ev-ft5726", .data = &edt_ft5506_data },
1495     /* Note focaltech vendor prefix for compatibility with ft6236.c */
1496     { .compatible = "focaltech,ft6236", .data = &edt_ft6236_data },
1497     { /* sentinel */ }
1498 };
1499 MODULE_DEVICE_TABLE(of, edt_ft5x06_of_match);
1500 
1501 static struct i2c_driver edt_ft5x06_ts_driver = {
1502     .driver = {
1503         .name = "edt_ft5x06",
1504         .of_match_table = edt_ft5x06_of_match,
1505         .pm = &edt_ft5x06_ts_pm_ops,
1506         .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1507     },
1508     .id_table = edt_ft5x06_ts_id,
1509     .probe    = edt_ft5x06_ts_probe,
1510     .remove   = edt_ft5x06_ts_remove,
1511 };
1512 
1513 module_i2c_driver(edt_ft5x06_ts_driver);
1514 
1515 MODULE_AUTHOR("Simon Budig <simon.budig@kernelconcepts.de>");
1516 MODULE_DESCRIPTION("EDT FT5x06 I2C Touchscreen Driver");
1517 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!