/*
   *  Atmel AT42QT1070 QTouch Sensor Controller
   *
   *  Copyright (C) 2011 Atmel
   *
   *  Authors: Bo Shen <voice.shen@atmel.com>
   *
   *  Base on AT42QT2160 driver by:
   *  Raphael Derosso Pereira <raphaelpereira@gmail.com>
   *  Copyright (C) 2009
   *
   *  This program is free software; you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation; either version 2 of the License, or
   *  (at your option) any later version.
   *
   *  This program is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to the Free Software
   *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   */
  #include <linux/kernel.h>
  #include <linux/module.h>
  #include <linux/i2c.h>
  #include <linux/input.h>
  #include <linux/slab.h>
  #include <linux/irq.h>
  #include <linux/interrupt.h>
  #include <linux/jiffies.h>
  #include <linux/delay.h>
  
  /* Address for each register */
  #define CHIP_ID            0x00
  #define QT1070_CHIP_ID     0x2E
  
  #define FW_VERSION         0x01
  #define QT1070_FW_VERSION  0x15
  
  #define DET_STATUS         0x02
  
  #define KEY_STATUS         0x03
  
  /* Calibrate */
  #define CALIBRATE_CMD      0x38
  #define QT1070_CAL_TIME    200
  
  /* Reset */
  #define RESET              0x39
  #define QT1070_RESET_TIME  255
  
  /* AT42QT1070 support up to 7 keys */
  static const unsigned short qt1070_key2code[] = {
  	KEY_0, KEY_1, KEY_2, KEY_3,
  	KEY_4, KEY_5, KEY_6,
  };
  
  struct qt1070_data {
  	struct i2c_client *client;
  	struct input_dev *input;
  	unsigned int irq;
  	unsigned short keycodes[ARRAY_SIZE(qt1070_key2code)];
  	u8 last_keys;
  };
  
  static int qt1070_read(struct i2c_client *client, u8 reg)
  {
  	int ret;
  
  	ret = i2c_smbus_read_byte_data(client, reg);
  	if (ret < 0)
  		dev_err(&client->dev,
  			"can not read register, returned %d
  ", ret);
  
  	return ret;
  }
  
  static int qt1070_write(struct i2c_client *client, u8 reg, u8 data)
  {
  	int ret;
  
  	ret = i2c_smbus_write_byte_data(client, reg, data);
  	if (ret < 0)
  		dev_err(&client->dev,
  			"can not write register, returned %d
  ", ret);
  
  	return ret;
  }
  
  static bool qt1070_identify(struct i2c_client *client)
  {
  	int id, ver;
  
  	/* Read Chip ID */
  	id = qt1070_read(client, CHIP_ID);
  	if (id != QT1070_CHIP_ID) {
  		dev_err(&client->dev, "ID %d not supported
  ", id);
  		return false;
  	}
  
  	/* Read firmware version */
  	ver = qt1070_read(client, FW_VERSION);
  	if (ver < 0) {
  		dev_err(&client->dev, "could not read the firmware version
  ");
  		return false;
  	}
  
  	dev_info(&client->dev, "AT42QT1070 firmware version %x
  ", ver);
  
  	return true;
  }
  
  static irqreturn_t qt1070_interrupt(int irq, void *dev_id)
  {
  	struct qt1070_data *data = dev_id;
  	struct i2c_client *client = data->client;
  	struct input_dev *input = data->input;
  	int i;
  	u8 new_keys, keyval, mask = 0x01;
  
  	/* Read the detected status register, thus clearing interrupt */
  	qt1070_read(client, DET_STATUS);
  
  	/* Read which key changed */
  	new_keys = qt1070_read(client, KEY_STATUS);
  
  	for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
  		keyval = new_keys & mask;
  		if ((data->last_keys & mask) != keyval)
  			input_report_key(input, data->keycodes[i], keyval);
  		mask <<= 1;
  	}
  	input_sync(input);
  
  	data->last_keys = new_keys;
  	return IRQ_HANDLED;
  }
  
  static int qt1070_probe(struct i2c_client *client,
  				const struct i2c_device_id *id)
  {
  	struct qt1070_data *data;
  	struct input_dev *input;
  	int i;
  	int err;
  
  	err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE);
  	if (!err) {
  		dev_err(&client->dev, "%s adapter not supported
  ",
  			dev_driver_string(&client->adapter->dev));
  		return -ENODEV;
  	}
  
  	if (!client->irq) {
  		dev_err(&client->dev, "please assign the irq to this device
  ");
  		return -EINVAL;
  	}
  
  	/* Identify the qt1070 chip */
  	if (!qt1070_identify(client))
  		return -ENODEV;
  
  	data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL);
  	input = input_allocate_device();
  	if (!data || !input) {
  		dev_err(&client->dev, "insufficient memory
  ");
  		err = -ENOMEM;
  		goto err_free_mem;
  	}
  
  	data->client = client;
  	data->input = input;
  	data->irq = client->irq;
  
  	input->name = "AT42QT1070 QTouch Sensor";
  	input->dev.parent = &client->dev;
  	input->id.bustype = BUS_I2C;
  
  	/* Add the keycode */
  	input->keycode = data->keycodes;
  	input->keycodesize = sizeof(data->keycodes[0]);
  	input->keycodemax = ARRAY_SIZE(qt1070_key2code);
  
  	__set_bit(EV_KEY, input->evbit);
  
  	for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
  		data->keycodes[i] = qt1070_key2code[i];
  		__set_bit(qt1070_key2code[i], input->keybit);
  	}
  
  	/* Calibrate device */
  	qt1070_write(client, CALIBRATE_CMD, 1);
  	msleep(QT1070_CAL_TIME);
  
  	/* Soft reset */
  	qt1070_write(client, RESET, 1);
  	msleep(QT1070_RESET_TIME);
  
  	err = request_threaded_irq(client->irq, NULL, qt1070_interrupt,
  				   IRQF_TRIGGER_NONE | IRQF_ONESHOT,
  				   client->dev.driver->name, data);
  	if (err) {
  		dev_err(&client->dev, "fail to request irq
  ");
  		goto err_free_mem;
  	}
  
  	/* Register the input device */
  	err = input_register_device(data->input);
  	if (err) {
  		dev_err(&client->dev, "Failed to register input device
  ");
  		goto err_free_irq;
  	}
  
  	i2c_set_clientdata(client, data);
  
  	/* Read to clear the chang line */
  	qt1070_read(client, DET_STATUS);
  
  	return 0;
  
  err_free_irq:
  	free_irq(client->irq, data);
  err_free_mem:
  	input_free_device(input);
  	kfree(data);
  	return err;
  }
  
  static int qt1070_remove(struct i2c_client *client)
  {
  	struct qt1070_data *data = i2c_get_clientdata(client);
  
  	/* Release IRQ */
  	free_irq(client->irq, data);
  
  	input_unregister_device(data->input);
  	kfree(data);
  
  	return 0;
  }
  
  #ifdef CONFIG_PM_SLEEP
  static int qt1070_suspend(struct device *dev)
  {
  	struct i2c_client *client = to_i2c_client(dev);
  	struct qt1070_data *data = i2c_get_clientdata(client);
  
  	if (device_may_wakeup(dev))
  		enable_irq_wake(data->irq);
  
  	return 0;
  }
  
  static int qt1070_resume(struct device *dev)
  {
  	struct i2c_client *client = to_i2c_client(dev);
  	struct qt1070_data *data = i2c_get_clientdata(client);
  
  	if (device_may_wakeup(dev))
  		disable_irq_wake(data->irq);
  
  	return 0;
  }
  #endif
  
  static SIMPLE_DEV_PM_OPS(qt1070_pm_ops, qt1070_suspend, qt1070_resume);
  
  static const struct i2c_device_id qt1070_id[] = {
  	{ "qt1070", 0 },
  	{ },
  };
  MODULE_DEVICE_TABLE(i2c, qt1070_id);
  
  static struct i2c_driver qt1070_driver = {
  	.driver	= {
  		.name	= "qt1070",
  		.owner	= THIS_MODULE,
  		.pm	= &qt1070_pm_ops,
  	},
  	.id_table	= qt1070_id,
  	.probe		= qt1070_probe,
  	.remove		= qt1070_remove,
  };
  
  module_i2c_driver(qt1070_driver);
  
  MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>");
  MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor");
  MODULE_LICENSE("GPL");