input/keyboard/qt2160.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  qt2160.c - Atmel AT42QT2160 Touch Sense Controller
0004  *
0005  *  Copyright (C) 2009 Raphael Derosso Pereira <raphaelpereira@gmail.com>
0006  */
0007
0008 #include <linux/kernel.h>
0009 #include <linux/leds.h>
0010 #include <linux/module.h>
0011 #include <linux/slab.h>
0012 #include <linux/jiffies.h>
0013 #include <linux/i2c.h>
0014 #include <linux/irq.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/input.h>
0017
0018 #define QT2160_VALID_CHIPID  0x11
0019
0020 #define QT2160_CMD_CHIPID     0
0021 #define QT2160_CMD_CODEVER    1
0022 #define QT2160_CMD_GSTAT      2
0023 #define QT2160_CMD_KEYS3      3
0024 #define QT2160_CMD_KEYS4      4
0025 #define QT2160_CMD_SLIDE      5
0026 #define QT2160_CMD_GPIOS      6
0027 #define QT2160_CMD_SUBVER     7
0028 #define QT2160_CMD_CALIBRATE  10
0029 #define QT2160_CMD_DRIVE_X    70
0030 #define QT2160_CMD_PWMEN_X    74
0031 #define QT2160_CMD_PWM_DUTY   76
0032
0033 #define QT2160_NUM_LEDS_X   8
0034
0035 #define QT2160_CYCLE_INTERVAL   (2*HZ)
0036
0037 static unsigned char qt2160_key2code[] = {
0038     KEY_0, KEY_1, KEY_2, KEY_3,
0039     KEY_4, KEY_5, KEY_6, KEY_7,
0040     KEY_8, KEY_9, KEY_A, KEY_B,
0041     KEY_C, KEY_D, KEY_E, KEY_F,
0042 };
0043
0044 #ifdef CONFIG_LEDS_CLASS
0045 struct qt2160_led {
0046     struct qt2160_data *qt2160;
0047     struct led_classdev cdev;
0048     char name[32];
0049     int id;
0050     enum led_brightness brightness;
0051 };
0052 #endif
0053
0054 struct qt2160_data {
0055     struct i2c_client *client;
0056     struct input_dev *input;
0057     struct delayed_work dwork;
0058     unsigned short keycodes[ARRAY_SIZE(qt2160_key2code)];
0059     u16 key_matrix;
0060 #ifdef CONFIG_LEDS_CLASS
0061     struct qt2160_led leds[QT2160_NUM_LEDS_X];
0062 #endif
0063 };
0064
0065 static int qt2160_read(struct i2c_client *client, u8 reg);
0066 static int qt2160_write(struct i2c_client *client, u8 reg, u8 data);
0067
0068 #ifdef CONFIG_LEDS_CLASS
0069
0070 static int qt2160_led_set(struct led_classdev *cdev,
0071               enum led_brightness value)
0072 {
0073     struct qt2160_led *led = container_of(cdev, struct qt2160_led, cdev);
0074     struct qt2160_data *qt2160 = led->qt2160;
0075     struct i2c_client *client = qt2160->client;
0076     u32 drive, pwmen;
0077
0078     if (value != led->brightness) {
0079         drive = qt2160_read(client, QT2160_CMD_DRIVE_X);
0080         pwmen = qt2160_read(client, QT2160_CMD_PWMEN_X);
0081         if (value != LED_OFF) {
0082             drive |= BIT(led->id);
0083             pwmen |= BIT(led->id);
0084
0085         } else {
0086             drive &= ~BIT(led->id);
0087             pwmen &= ~BIT(led->id);
0088         }
0089         qt2160_write(client, QT2160_CMD_DRIVE_X, drive);
0090         qt2160_write(client, QT2160_CMD_PWMEN_X, pwmen);
0091
0092         /*
0093          * Changing this register will change the brightness
0094          * of every LED in the qt2160. It's a HW limitation.
0095          */
0096         if (value != LED_OFF)
0097             qt2160_write(client, QT2160_CMD_PWM_DUTY, value);
0098
0099         led->brightness = value;
0100     }
0101
0102     return 0;
0103 }
0104
0105 #endif /* CONFIG_LEDS_CLASS */
0106
0107 static int qt2160_read_block(struct i2c_client *client,
0108                  u8 inireg, u8 *buffer, unsigned int count)
0109 {
0110     int error, idx = 0;
0111
0112     /*
0113      * Can't use SMBus block data read. Check for I2C functionality to speed
0114      * things up whenever possible. Otherwise we will be forced to read
0115      * sequentially.
0116      */
0117     if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
0118
0119         error = i2c_smbus_write_byte(client, inireg + idx);
0120         if (error) {
0121             dev_err(&client->dev,
0122                 "couldn't send request. Returned %d\n", error);
0123             return error;
0124         }
0125
0126         error = i2c_master_recv(client, buffer, count);
0127         if (error != count) {
0128             dev_err(&client->dev,
0129                 "couldn't read registers. Returned %d bytes\n", error);
0130             return error;
0131         }
0132     } else {
0133
0134         while (count--) {
0135             int data;
0136
0137             error = i2c_smbus_write_byte(client, inireg + idx);
0138             if (error) {
0139                 dev_err(&client->dev,
0140                     "couldn't send request. Returned %d\n", error);
0141                 return error;
0142             }
0143
0144             data = i2c_smbus_read_byte(client);
0145             if (data < 0) {
0146                 dev_err(&client->dev,
0147                     "couldn't read register. Returned %d\n", data);
0148                 return data;
0149             }
0150
0151             buffer[idx++] = data;
0152         }
0153     }
0154
0155     return 0;
0156 }
0157
0158 static int qt2160_get_key_matrix(struct qt2160_data *qt2160)
0159 {
0160     struct i2c_client *client = qt2160->client;
0161     struct input_dev *input = qt2160->input;
0162     u8 regs[6];
0163     u16 old_matrix, new_matrix;
0164     int ret, i, mask;
0165
0166     dev_dbg(&client->dev, "requesting keys...\n");
0167
0168     /*
0169      * Read all registers from General Status Register
0170      * to GPIOs register
0171      */
0172     ret = qt2160_read_block(client, QT2160_CMD_GSTAT, regs, 6);
0173     if (ret) {
0174         dev_err(&client->dev,
0175             "could not perform chip read.\n");
0176         return ret;
0177     }
0178
0179     old_matrix = qt2160->key_matrix;
0180     qt2160->key_matrix = new_matrix = (regs[2] << 8) | regs[1];
0181
0182     mask = 0x01;
0183     for (i = 0; i < 16; ++i, mask <<= 1) {
0184         int keyval = new_matrix & mask;
0185
0186         if ((old_matrix & mask) != keyval) {
0187             input_report_key(input, qt2160->keycodes[i], keyval);
0188             dev_dbg(&client->dev, "key %d %s\n",
0189                 i, keyval ? "pressed" : "released");
0190         }
0191     }
0192
0193     input_sync(input);
0194
0195     return 0;
0196 }
0197
0198 static irqreturn_t qt2160_irq(int irq, void *_qt2160)
0199 {
0200     struct qt2160_data *qt2160 = _qt2160;
0201
0202     mod_delayed_work(system_wq, &qt2160->dwork, 0);
0203
0204     return IRQ_HANDLED;
0205 }
0206
0207 static void qt2160_schedule_read(struct qt2160_data *qt2160)
0208 {
0209     schedule_delayed_work(&qt2160->dwork, QT2160_CYCLE_INTERVAL);
0210 }
0211
0212 static void qt2160_worker(struct work_struct *work)
0213 {
0214     struct qt2160_data *qt2160 =
0215         container_of(work, struct qt2160_data, dwork.work);
0216
0217     dev_dbg(&qt2160->client->dev, "worker\n");
0218
0219     qt2160_get_key_matrix(qt2160);
0220
0221     /* Avoid device lock up by checking every so often */
0222     qt2160_schedule_read(qt2160);
0223 }
0224
0225 static int qt2160_read(struct i2c_client *client, u8 reg)
0226 {
0227     int ret;
0228
0229     ret = i2c_smbus_write_byte(client, reg);
0230     if (ret) {
0231         dev_err(&client->dev,
0232             "couldn't send request. Returned %d\n", ret);
0233         return ret;
0234     }
0235
0236     ret = i2c_smbus_read_byte(client);
0237     if (ret < 0) {
0238         dev_err(&client->dev,
0239             "couldn't read register. Returned %d\n", ret);
0240         return ret;
0241     }
0242
0243     return ret;
0244 }
0245
0246 static int qt2160_write(struct i2c_client *client, u8 reg, u8 data)
0247 {
0248     int ret;
0249
0250     ret = i2c_smbus_write_byte_data(client, reg, data);
0251     if (ret < 0)
0252         dev_err(&client->dev,
0253             "couldn't write data. Returned %d\n", ret);
0254
0255     return ret;
0256 }
0257
0258 #ifdef CONFIG_LEDS_CLASS
0259
0260 static int qt2160_register_leds(struct qt2160_data *qt2160)
0261 {
0262     struct i2c_client *client = qt2160->client;
0263     int ret;
0264     int i;
0265
0266     for (i = 0; i < QT2160_NUM_LEDS_X; i++) {
0267         struct qt2160_led *led = &qt2160->leds[i];
0268
0269         snprintf(led->name, sizeof(led->name), "qt2160:x%d", i);
0270         led->cdev.name = led->name;
0271         led->cdev.brightness_set_blocking = qt2160_led_set;
0272         led->cdev.brightness = LED_OFF;
0273         led->id = i;
0274         led->qt2160 = qt2160;
0275
0276         ret = led_classdev_register(&client->dev, &led->cdev);
0277         if (ret < 0)
0278             return ret;
0279     }
0280
0281     /* Tur off LEDs */
0282     qt2160_write(client, QT2160_CMD_DRIVE_X, 0);
0283     qt2160_write(client, QT2160_CMD_PWMEN_X, 0);
0284     qt2160_write(client, QT2160_CMD_PWM_DUTY, 0);
0285
0286     return 0;
0287 }
0288
0289 static void qt2160_unregister_leds(struct qt2160_data *qt2160)
0290 {
0291     int i;
0292
0293     for (i = 0; i < QT2160_NUM_LEDS_X; i++)
0294         led_classdev_unregister(&qt2160->leds[i].cdev);
0295 }
0296
0297 #else
0298
0299 static inline int qt2160_register_leds(struct qt2160_data *qt2160)
0300 {
0301     return 0;
0302 }
0303
0304 static inline void qt2160_unregister_leds(struct qt2160_data *qt2160)
0305 {
0306 }
0307
0308 #endif
0309
0310 static bool qt2160_identify(struct i2c_client *client)
0311 {
0312     int id, ver, rev;
0313
0314     /* Read Chid ID to check if chip is valid */
0315     id = qt2160_read(client, QT2160_CMD_CHIPID);
0316     if (id != QT2160_VALID_CHIPID) {
0317         dev_err(&client->dev, "ID %d not supported\n", id);
0318         return false;
0319     }
0320
0321     /* Read chip firmware version */
0322     ver = qt2160_read(client, QT2160_CMD_CODEVER);
0323     if (ver < 0) {
0324         dev_err(&client->dev, "could not get firmware version\n");
0325         return false;
0326     }
0327
0328     /* Read chip firmware revision */
0329     rev = qt2160_read(client, QT2160_CMD_SUBVER);
0330     if (rev < 0) {
0331         dev_err(&client->dev, "could not get firmware revision\n");
0332         return false;
0333     }
0334
0335     dev_info(&client->dev, "AT42QT2160 firmware version %d.%d.%d\n",
0336             ver >> 4, ver & 0xf, rev);
0337
0338     return true;
0339 }
0340
0341 static int qt2160_probe(struct i2c_client *client,
0342             const struct i2c_device_id *id)
0343 {
0344     struct qt2160_data *qt2160;
0345     struct input_dev *input;
0346     int i;
0347     int error;
0348
0349     /* Check functionality */
0350     error = i2c_check_functionality(client->adapter,
0351             I2C_FUNC_SMBUS_BYTE);
0352     if (!error) {
0353         dev_err(&client->dev, "%s adapter not supported\n",
0354                 dev_driver_string(&client->adapter->dev));
0355         return -ENODEV;
0356     }
0357
0358     if (!qt2160_identify(client))
0359         return -ENODEV;
0360
0361     /* Chip is valid and active. Allocate structure */
0362     qt2160 = kzalloc(sizeof(struct qt2160_data), GFP_KERNEL);
0363     input = input_allocate_device();
0364     if (!qt2160 || !input) {
0365         dev_err(&client->dev, "insufficient memory\n");
0366         error = -ENOMEM;
0367         goto err_free_mem;
0368     }
0369
0370     qt2160->client = client;
0371     qt2160->input = input;
0372     INIT_DELAYED_WORK(&qt2160->dwork, qt2160_worker);
0373
0374     input->name = "AT42QT2160 Touch Sense Keyboard";
0375     input->id.bustype = BUS_I2C;
0376
0377     input->keycode = qt2160->keycodes;
0378     input->keycodesize = sizeof(qt2160->keycodes[0]);
0379     input->keycodemax = ARRAY_SIZE(qt2160_key2code);
0380
0381     __set_bit(EV_KEY, input->evbit);
0382     __clear_bit(EV_REP, input->evbit);
0383     for (i = 0; i < ARRAY_SIZE(qt2160_key2code); i++) {
0384         qt2160->keycodes[i] = qt2160_key2code[i];
0385         __set_bit(qt2160_key2code[i], input->keybit);
0386     }
0387     __clear_bit(KEY_RESERVED, input->keybit);
0388
0389     /* Calibrate device */
0390     error = qt2160_write(client, QT2160_CMD_CALIBRATE, 1);
0391     if (error) {
0392         dev_err(&client->dev, "failed to calibrate device\n");
0393         goto err_free_mem;
0394     }
0395
0396     if (client->irq) {
0397         error = request_irq(client->irq, qt2160_irq,
0398                     IRQF_TRIGGER_FALLING, "qt2160", qt2160);
0399         if (error) {
0400             dev_err(&client->dev,
0401                 "failed to allocate irq %d\n", client->irq);
0402             goto err_free_mem;
0403         }
0404     }
0405
0406     error = qt2160_register_leds(qt2160);
0407     if (error) {
0408         dev_err(&client->dev, "Failed to register leds\n");
0409         goto err_free_irq;
0410     }
0411
0412     error = input_register_device(qt2160->input);
0413     if (error) {
0414         dev_err(&client->dev,
0415             "Failed to register input device\n");
0416         goto err_unregister_leds;
0417     }
0418
0419     i2c_set_clientdata(client, qt2160);
0420     qt2160_schedule_read(qt2160);
0421
0422     return 0;
0423
0424 err_unregister_leds:
0425     qt2160_unregister_leds(qt2160);
0426 err_free_irq:
0427     if (client->irq)
0428         free_irq(client->irq, qt2160);
0429 err_free_mem:
0430     input_free_device(input);
0431     kfree(qt2160);
0432     return error;
0433 }
0434
0435 static int qt2160_remove(struct i2c_client *client)
0436 {
0437     struct qt2160_data *qt2160 = i2c_get_clientdata(client);
0438
0439     qt2160_unregister_leds(qt2160);
0440
0441     /* Release IRQ so no queue will be scheduled */
0442     if (client->irq)
0443         free_irq(client->irq, qt2160);
0444
0445     cancel_delayed_work_sync(&qt2160->dwork);
0446
0447     input_unregister_device(qt2160->input);
0448     kfree(qt2160);
0449
0450     return 0;
0451 }
0452
0453 static const struct i2c_device_id qt2160_idtable[] = {
0454     { "qt2160", 0, },
0455     { }
0456 };
0457
0458 MODULE_DEVICE_TABLE(i2c, qt2160_idtable);
0459
0460 static struct i2c_driver qt2160_driver = {
0461     .driver = {
0462         .name   = "qt2160",
0463     },
0464
0465     .id_table   = qt2160_idtable,
0466     .probe      = qt2160_probe,
0467     .remove     = qt2160_remove,
0468 };
0469
0470 module_i2c_driver(qt2160_driver);
0471
0472 MODULE_AUTHOR("Raphael Derosso Pereira <raphaelpereira@gmail.com>");
0473 MODULE_DESCRIPTION("Driver for AT42QT2160 Touch Sensor");
0474 MODULE_LICENSE("GPL");