1 files changed, 421 insertions, 0 deletions

diff --git a/drivers/input/touchscreen/rmi4/rmi_i2c.c b/drivers/input/touchscreen/rmi4/rmi_i2c.c
new file mode 100644
index 00000000000..15624f9cf54
--- /dev/null
+++ b/drivers/input/touchscreen/rmi4/rmi_i2c.c
@@ -0,0 +1,421 @@
+/*
+ * Copyright (c) 2011 Synaptics Incorporated
+ * Copyright (c) 2011 Unixphere
+ *
+ * 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/lockdep.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/pm.h>
+#include <linux/gpio.h>
+#include <linux/rmi.h>
+
+#define COMMS_DEBUG 0
+
+#define IRQ_DEBUG 0
+
+#define RMI_PAGE_SELECT_REGISTER 0xff
+#define RMI_I2C_PAGE(addr) (((addr) >> 8) & 0xff)
+
+static char *phys_proto_name = "i2c";
+
+struct rmi_i2c_data {
+        struct mutex page_mutex;
+        int page;
+        int enabled;
+        int irq;
+        int irq_flags;
+        struct rmi_phys_device *phys;
+};
+
+static irqreturn_t rmi_i2c_irq_thread(int irq, void *p)
+{
+        struct rmi_phys_device *phys = p;
+        struct rmi_device *rmi_dev = phys->rmi_dev;
+        struct rmi_driver *driver = rmi_dev->driver;
+        struct rmi_device_platform_data *pdata = phys->dev->platform_data;
+
+#if IRQ_DEBUG
+        dev_dbg(phys->dev, "ATTN gpio, value: %d.\n",
+                        gpio_get_value(irq_to_gpio(irq)));
+#endif
+        if (gpio_get_value(irq_to_gpio(irq)) == pdata->irq_polarity) {
+                phys->info.attn_count++;
+                if (driver && driver->irq_handler && rmi_dev)
+                        driver->irq_handler(rmi_dev, irq);
+        }
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * rmi_set_page - Set RMI page
+ * @phys: The pointer to the rmi_phys_device struct
+ * @page: The new page address.
+ *
+ * RMI devices have 16-bit addressing, but some of the physical
+ * implementations (like SMBus) only have 8-bit addressing. So RMI implements
+ * a page address at 0xff of every page so we can reliable page addresses
+ * every 256 registers.
+ *
+ * The page_mutex lock must be held when this function is entered.
+ *
+ * Returns zero on success, non-zero on failure.
+ */
+static int rmi_set_page(struct rmi_phys_device *phys, unsigned int page)
+{
+        struct i2c_client *client = to_i2c_client(phys->dev);
+        struct rmi_i2c_data *data = phys->data;
+        char txbuf[2] = {RMI_PAGE_SELECT_REGISTER, page};
+        int retval;
+
+#if COMMS_DEBUG
+        dev_dbg(&client->dev, "RMI4 I2C writes 3 bytes: %02x %02x\n",
+                txbuf[0], txbuf[1]);
+#endif
+        phys->info.tx_count++;
+        phys->info.tx_bytes += sizeof(txbuf);
+        retval = i2c_master_send(client, txbuf, sizeof(txbuf));
+        if (retval != sizeof(txbuf)) {
+                phys->info.tx_errs++;
+                dev_err(&client->dev,
+                        "%s: set page failed: %d.", __func__, retval);
+                return (retval < 0) ? retval : -EIO;
+        }
+        data->page = page;
+        return 0;
+}
+
+static int rmi_i2c_write_block(struct rmi_phys_device *phys, u16 addr, u8 *buf,
+                               int len)
+{
+        struct i2c_client *client = to_i2c_client(phys->dev);
+        struct rmi_i2c_data *data = phys->data;
+        u8 txbuf[len + 1];
+        int retval;
+#if     COMMS_DEBUG
+        int i;
+#endif
+
+        txbuf[0] = addr & 0xff;
+        memcpy(txbuf + 1, buf, len);
+
+        mutex_lock(&data->page_mutex);
+
+        if (RMI_I2C_PAGE(addr) != data->page) {
+                retval = rmi_set_page(phys, RMI_I2C_PAGE(addr));
+                if (retval < 0)
+                        goto exit;
+        }
+
+#if COMMS_DEBUG
+        dev_dbg(&client->dev, "RMI4 I2C writes %d bytes: ", sizeof(txbuf));
+        for (i = 0; i < sizeof(txbuf); i++)
+                dev_dbg(&client->dev, "%02x ", txbuf[i]);
+        dev_dbg(&client->dev, "\n");
+#endif
+
+        phys->info.tx_count++;
+        phys->info.tx_bytes += sizeof(txbuf);
+        retval = i2c_master_send(client, txbuf, sizeof(txbuf));
+        if (retval < 0)
+                phys->info.tx_errs++;
+
+exit:
+        mutex_unlock(&data->page_mutex);
+        return retval;
+}
+
+static int rmi_i2c_write(struct rmi_phys_device *phys, u16 addr, u8 data)
+{
+        int retval = rmi_i2c_write_block(phys, addr, &data, 1);
+        return (retval < 0) ? retval : 0;
+}
+
+static int rmi_i2c_read_block(struct rmi_phys_device *phys, u16 addr, u8 *buf,
+                              int len)
+{
+        struct i2c_client *client = to_i2c_client(phys->dev);
+        struct rmi_i2c_data *data = phys->data;
+        u8 txbuf[1] = {addr & 0xff};
+        int retval;
+#if     COMMS_DEBUG
+        int i;
+#endif
+
+        mutex_lock(&data->page_mutex);
+
+        if (RMI_I2C_PAGE(addr) != data->page) {
+                retval = rmi_set_page(phys, RMI_I2C_PAGE(addr));
+                if (retval < 0)
+                        goto exit;
+        }
+
+#if COMMS_DEBUG
+        dev_dbg(&client->dev, "RMI4 I2C writes 1 bytes: %02x\n", txbuf[0]);
+#endif
+        phys->info.tx_count++;
+        phys->info.tx_bytes += sizeof(txbuf);
+        retval = i2c_master_send(client, txbuf, sizeof(txbuf));
+        if (retval != sizeof(txbuf)) {
+                phys->info.tx_errs++;
+                retval = (retval < 0) ? retval : -EIO;
+                goto exit;
+        }
+
+        retval = i2c_master_recv(client, buf, len);
+
+        phys->info.rx_count++;
+        phys->info.rx_bytes += len;
+        if (retval < 0)
+                phys->info.rx_errs++;
+#if COMMS_DEBUG
+        else {
+                dev_dbg(&client->dev, "RMI4 I2C received %d bytes: ", len);
+                for (i = 0; i < len; i++)
+                        dev_dbg(&client->dev, "%02x ", buf[i]);
+                dev_dbg(&client->dev, "\n");
+        }
+#endif
+
+exit:
+        mutex_unlock(&data->page_mutex);
+        return retval;
+}
+
+static int rmi_i2c_read(struct rmi_phys_device *phys, u16 addr, u8 *buf)
+{
+        int retval = rmi_i2c_read_block(phys, addr, buf, 1);
+        return (retval < 0) ? retval : 0;
+}
+
+
+static int acquire_attn_irq(struct rmi_i2c_data *data)
+{
+        return request_threaded_irq(data->irq, NULL, rmi_i2c_irq_thread,
+                        data->irq_flags, dev_name(data->phys->dev), data->phys);
+}
+
+static int enable_device(struct rmi_phys_device *phys)
+{
+        int retval = 0;
+
+        struct rmi_i2c_data *data = phys->data;
+
+        if (data->enabled)
+                return 0;
+
+        retval = acquire_attn_irq(data);
+        if (retval)
+                goto error_exit;
+
+        data->enabled = true;
+        dev_dbg(phys->dev, "Physical device enabled.\n");
+        return 0;
+
+error_exit:
+        dev_err(phys->dev, "Failed to enable physical device. Code=%d.\n",
+                retval);
+        return retval;
+}
+
+
+static void disable_device(struct rmi_phys_device *phys)
+{
+        struct rmi_i2c_data *data = phys->data;
+
+        if (!data->enabled)
+                return;
+
+        disable_irq(data->irq);
+        free_irq(data->irq, data->phys);
+
+        dev_dbg(phys->dev, "Physical device disabled.\n");
+        data->enabled = false;
+}
+
+
+static int __devinit rmi_i2c_probe(struct i2c_client *client,
+                                  const struct i2c_device_id *id)
+{
+        struct rmi_phys_device *rmi_phys;
+        struct rmi_i2c_data *data;
+        struct rmi_device_platform_data *pdata = client->dev.platform_data;
+        int error;
+
+        if (!pdata) {
+                dev_err(&client->dev, "no platform data\n");
+                return -EINVAL;
+        }
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+                dev_err(&client->dev, "i2c_check_functionality error\n");
+                return -EIO;
+        }
+
+        rmi_phys = kzalloc(sizeof(struct rmi_phys_device), GFP_KERNEL);
+        if (!rmi_phys)
+                return -ENOMEM;
+
+        data = kzalloc(sizeof(struct rmi_i2c_data), GFP_KERNEL);
+        if (!data) {
+                error = -ENOMEM;
+                goto err_phys;
+        }
+
+        data->enabled = true;   /* We plan to come up enabled. */
+        data->irq = gpio_to_irq(pdata->irq);
+        data->irq_flags = (pdata->irq_polarity == RMI_IRQ_ACTIVE_HIGH) ?
+                IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
+        data->phys = rmi_phys;
+
+        rmi_phys->data = data;
+        rmi_phys->dev = &client->dev;
+
+        rmi_phys->write = rmi_i2c_write;
+        rmi_phys->write_block = rmi_i2c_write_block;
+        rmi_phys->read = rmi_i2c_read;
+        rmi_phys->read_block = rmi_i2c_read_block;
+        rmi_phys->enable_device = enable_device;
+        rmi_phys->disable_device = disable_device;
+
+        rmi_phys->info.proto = phys_proto_name;
+
+        mutex_init(&data->page_mutex);
+
+        /* Setting the page to zero will (a) make sure the PSR is in a
+         * known state, and (b) make sure we can talk to the device.
+         */
+        error = rmi_set_page(rmi_phys, 0);
+        if (error) {
+                dev_err(&client->dev, "Failed to set page select to 0.\n");
+                goto err_data;
+        }
+
+        if (pdata->gpio_config) {
+                error = pdata->gpio_config(&client->dev, true);
+                if (error < 0) {
+                        dev_err(&client->dev, "failed to setup irq %d\n",
+                                pdata->irq);
+                        goto err_data;
+                }
+        }
+
+        error = rmi_register_phys_device(rmi_phys);
+        if (error) {
+                dev_err(&client->dev,
+                        "failed to register physical driver at 0x%.2X.\n",
+                        client->addr);
+                goto err_data;
+        }
+        i2c_set_clientdata(client, rmi_phys);
+
+        if (pdata->irq > 0) {
+                error = acquire_attn_irq(data);
+                if (error < 0) {
+                        dev_err(&client->dev,
+                                "request_threaded_irq failed %d\n",
+                                pdata->irq);
+                        goto err_unregister;
+                }
+        }
+
+#if defined(CONFIG_RMI4_DEV)
+        error = gpio_export(pdata->irq, false);
+        if (error) {
+                dev_warn(&client->dev, "%s: WARNING: Failed to "
+                                 "export ATTN gpio!\n", __func__);
+                error = 0;
+        } else {
+                error = gpio_export_link(&(rmi_phys->rmi_dev->dev), "attn",
+                                        pdata->irq);
+                if (error) {
+                        dev_warn(&(rmi_phys->rmi_dev->dev), "%s: WARNING: "
+                                "Failed to symlink ATTN gpio!\n", __func__);
+                        error = 0;
+                } else {
+                        dev_info(&(rmi_phys->rmi_dev->dev),
+                                "%s: Exported GPIO %d.", __func__, pdata->irq);
+                }
+        }
+#endif /* CONFIG_RMI4_DEV */
+
+        dev_info(&client->dev, "registered rmi i2c driver at 0x%.2X.\n",
+                        client->addr);
+        return 0;
+
+err_unregister:
+        rmi_unregister_phys_device(rmi_phys);
+err_data:
+        kfree(data);
+err_phys:
+        kfree(rmi_phys);
+        return error;
+}
+
+static int __devexit rmi_i2c_remove(struct i2c_client *client)
+{
+        struct rmi_phys_device *phys = i2c_get_clientdata(client);
+        struct rmi_device_platform_data *pd = client->dev.platform_data;
+
+        rmi_unregister_phys_device(phys);
+        kfree(phys->data);
+        kfree(phys);
+
+        if (pd->gpio_config)
+                pd->gpio_config(&client->dev, false);
+
+        return 0;
+}
+
+static const struct i2c_device_id rmi_id[] = {
+        { "rmi", 0 },
+        { "rmi-i2c", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, rmi_id);
+
+static struct i2c_driver rmi_i2c_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "rmi-i2c"
+        },
+        .id_table       = rmi_id,
+        .probe          = rmi_i2c_probe,
+        .remove         = __devexit_p(rmi_i2c_remove),
+};
+
+static int __init rmi_i2c_init(void)
+{
+        return i2c_add_driver(&rmi_i2c_driver);
+}
+
+static void __exit rmi_i2c_exit(void)
+{
+        i2c_del_driver(&rmi_i2c_driver);
+}
+
+MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com>");
+MODULE_AUTHOR("Eric Andersson <eric.andersson@unixphere.com>");
+MODULE_DESCRIPTION("RMI i2c driver");
+MODULE_LICENSE("GPL");
+
+module_init(rmi_i2c_init);
+module_exit(rmi_i2c_exit);