| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-Id: <1346703805-31598-3-git-send-email-aaro.koskinen@iki.fi>
Date: Mon, 3 Sep 2012 23:23:23 +0300
From: Aaro Koskinen <aaro.koskinen@....fi>
To: linux-omap@...r.kernel.org, linux-kernel@...r.kernel.org
Cc: sameo@...ux.intel.com
Subject: [PATCH 2/4] mfd: introduce retu-mfd driver
Retu is a multi-function device found on Nokia Internet Tablets
implementing at least watchdog, RTC, headset detection and power button
functionality.
This patch implements minimum functionality providing register access,
IRQ handling and power off functions.
Cc: sameo@...ux.intel.com
Acked-by: Tony Lindgren <tony@...mide.com>
Signed-off-by: Aaro Koskinen <aaro.koskinen@....fi>
---
drivers/mfd/Kconfig | 8 +
drivers/mfd/Makefile | 1 +
drivers/mfd/retu-mfd.c | 347 ++++++++++++++++++++++++++++++++++++++++++++++
include/linux/mfd/retu.h | 22 +++
4 files changed, 378 insertions(+), 0 deletions(-)
create mode 100644 drivers/mfd/retu-mfd.c
create mode 100644 include/linux/mfd/retu.h
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index b1a1462..7d4ce92 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -1003,6 +1003,14 @@ config MFD_PALMAS
If you say yes here you get support for the Palmas
series of PMIC chips from Texas Instruments.
+config MFD_RETU
+ tristate "Support for Retu multi-function device"
+ select MFD_CORE
+ depends on I2C
+ help
+ Retu is a multi-function device found on Nokia Internet Tablets
+ (770, N800 and N810).
+
endmenu
endif
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 79dd22d..962ec9d 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -132,3 +132,4 @@ obj-$(CONFIG_MFD_RC5T583) += rc5t583.o rc5t583-irq.o
obj-$(CONFIG_MFD_SEC_CORE) += sec-core.o sec-irq.o
obj-$(CONFIG_MFD_ANATOP) += anatop-mfd.o
obj-$(CONFIG_MFD_LM3533) += lm3533-core.o lm3533-ctrlbank.o
+obj-$(CONFIG_MFD_RETU) += retu-mfd.o
diff --git a/drivers/mfd/retu-mfd.c b/drivers/mfd/retu-mfd.c
new file mode 100644
index 0000000..99059d3
--- /dev/null
+++ b/drivers/mfd/retu-mfd.c
@@ -0,0 +1,347 @@
+/*
+ * Retu MFD driver
+ *
+ * Copyright (C) 2004, 2005 Nokia Corporation
+ *
+ * Based on code written by Juha Yrjölä, David Weinehall and Mikko Ylinen.
+ * Rewritten to MFD/I2C driver by Aaro Koskinen.
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of this
+ * archive for more details.
+ *
+ * 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.
+ */
+
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/irq.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/mutex.h>
+#include <linux/module.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/retu.h>
+#include <linux/interrupt.h>
+#include <linux/moduleparam.h>
+
+/* Registers */
+#define RETU_REG_ASICR 0x00 /* ASIC ID and revision */
+#define RETU_REG_ASICR_VILMA (1 << 7) /* Bit indicating Vilma */
+#define RETU_REG_IDR 0x01 /* Interrupt ID */
+#define RETU_REG_IMR 0x02 /* Interrupt mask */
+
+/* Interrupt sources */
+#define RETU_INT_PWR 0 /* Power button */
+
+#define RETU_MAX_IRQ_HANDLERS 16
+
+struct retu_dev {
+ struct device *dev;
+ struct i2c_client *i2c;
+ struct mutex mutex;
+
+ struct irq_chip irq_chip;
+ int irq_base;
+ int irq_end;
+ int irq_mask;
+ bool irq_mask_pending;
+};
+
+static struct resource retu_pwrbutton_res[] = {
+ {
+ .name = "retu-pwrbutton",
+ .start = RETU_INT_PWR,
+ .end = RETU_INT_PWR,
+ .flags = IORESOURCE_IRQ,
+ },
+};
+
+static struct mfd_cell retu_devs[] = {
+ {
+ .name = "retu-wdt"
+ },
+ {
+ .name = "retu-pwrbutton",
+ .resources = &retu_pwrbutton_res[0],
+ .num_resources = ARRAY_SIZE(retu_pwrbutton_res),
+ }
+};
+
+/* Retu device registered for the power off. */
+static struct retu_dev *retu_pm_power_off;
+
+int retu_read(struct retu_dev *rdev, u8 reg)
+{
+ int ret;
+
+ mutex_lock(&rdev->mutex);
+ ret = i2c_smbus_read_word_data(rdev->i2c, reg);
+ mutex_unlock(&rdev->mutex);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(retu_read);
+
+int retu_write(struct retu_dev *rdev, u8 reg, u16 data)
+{
+ int ret;
+
+ mutex_lock(&rdev->mutex);
+ ret = i2c_smbus_write_word_data(rdev->i2c, reg, data);
+ mutex_unlock(&rdev->mutex);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(retu_write);
+
+static void retu_power_off(void)
+{
+ struct retu_dev *rdev = retu_pm_power_off;
+ int reg;
+
+ mutex_lock(&retu_pm_power_off->mutex);
+
+ /* Ignore power button state */
+ reg = i2c_smbus_read_word_data(rdev->i2c, RETU_REG_CC1);
+ i2c_smbus_write_word_data(rdev->i2c, RETU_REG_CC1, reg | 2);
+
+ /* Expire watchdog immediately */
+ i2c_smbus_write_word_data(rdev->i2c, RETU_REG_WATCHDOG, 0);
+
+ /* Wait for poweroff */
+ for (;;)
+ cpu_relax();
+
+ mutex_unlock(&retu_pm_power_off->mutex);
+}
+
+static irqreturn_t retu_irq_handler(int irq, void *retu)
+{
+ struct retu_dev *rdev = retu;
+ int idr;
+ int imr;
+
+ mutex_lock(&rdev->mutex);
+
+ idr = i2c_smbus_read_word_data(rdev->i2c, RETU_REG_IDR);
+ if (idr < 0)
+ goto i2c_error;
+
+ imr = i2c_smbus_read_word_data(rdev->i2c, RETU_REG_IMR);
+ if (imr < 0)
+ goto i2c_error;
+
+ idr &= ~imr;
+ i2c_smbus_write_word_data(rdev->i2c, RETU_REG_IDR, idr);
+
+ mutex_unlock(&rdev->mutex);
+
+ if (!idr) {
+ dev_vdbg(rdev->dev, "No IRQ, spurious?\n");
+ return IRQ_NONE;
+ }
+
+ while (idr) {
+ unsigned long pending = __ffs(idr);
+ unsigned int irq;
+
+ idr &= ~BIT(pending);
+ irq = pending + rdev->irq_base;
+ handle_nested_irq(irq);
+ }
+
+ return IRQ_HANDLED;
+
+i2c_error:
+ mutex_unlock(&rdev->mutex);
+ return IRQ_NONE;
+}
+
+static void retu_irq_mask(struct irq_data *data)
+{
+ struct retu_dev *rdev = irq_data_get_irq_chip_data(data);
+ int irq = data->irq;
+
+ rdev->irq_mask |= (1 << (irq - rdev->irq_base));
+ rdev->irq_mask_pending = true;
+}
+
+static void retu_irq_unmask(struct irq_data *data)
+{
+ struct retu_dev *rdev = irq_data_get_irq_chip_data(data);
+ int irq = data->irq;
+
+ rdev->irq_mask &= ~(1 << (irq - rdev->irq_base));
+ rdev->irq_mask_pending = true;
+}
+
+static void retu_bus_lock(struct irq_data *data)
+{
+ struct retu_dev *rdev = irq_data_get_irq_chip_data(data);
+
+ mutex_lock(&rdev->mutex);
+}
+
+static void retu_bus_sync_unlock(struct irq_data *data)
+{
+ struct retu_dev *rdev = irq_data_get_irq_chip_data(data);
+
+ if (rdev->irq_mask_pending) {
+ i2c_smbus_write_word_data(rdev->i2c, RETU_REG_IMR,
+ rdev->irq_mask);
+ rdev->irq_mask_pending = false;
+ }
+ mutex_unlock(&rdev->mutex);
+}
+
+static void retu_irq_init(struct retu_dev *rdev)
+{
+ int base = rdev->irq_base;
+ int end = rdev->irq_end;
+ int irq;
+
+ rdev->irq_chip.name = "RETU";
+ rdev->irq_chip.irq_bus_lock = retu_bus_lock;
+ rdev->irq_chip.irq_bus_sync_unlock = retu_bus_sync_unlock;
+ rdev->irq_chip.irq_mask = retu_irq_mask;
+ rdev->irq_chip.irq_unmask = retu_irq_unmask;
+
+ for (irq = base; irq < end; irq++) {
+ irq_set_chip_data(irq, rdev);
+ irq_set_chip(irq, &rdev->irq_chip);
+ irq_set_nested_thread(irq, 1);
+#ifdef CONFIG_ARM
+ set_irq_flags(irq, IRQF_VALID);
+#else
+ irq_set_noprobe(irq);
+#endif
+ }
+
+ /* Mask all RETU interrupts */
+ rdev->irq_mask = 0xffff;
+ i2c_smbus_write_word_data(rdev->i2c, RETU_REG_IMR, rdev->irq_mask);
+}
+
+static void retu_irq_exit(struct retu_dev *rdev)
+{
+ int base = rdev->irq_base;
+ int end = rdev->irq_end;
+ int irq;
+
+ for (irq = base; irq < end; irq++) {
+#ifdef CONFIG_ARM
+ set_irq_flags(irq, 0);
+#endif
+ irq_set_chip_and_handler(irq, NULL, NULL);
+ irq_set_chip_data(irq, NULL);
+ }
+}
+
+static int __devinit retu_probe(struct i2c_client *i2c,
+ const struct i2c_device_id *id)
+{
+ struct retu_dev *rdev;
+ int ret;
+
+ rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
+ if (rdev == NULL)
+ return -ENOMEM;
+
+ i2c_set_clientdata(i2c, rdev);
+ rdev->dev = &i2c->dev;
+ rdev->i2c = i2c;
+ mutex_init(&rdev->mutex);
+
+ ret = retu_read(rdev, RETU_REG_ASICR);
+ if (ret < 0) {
+ dev_err(rdev->dev, "could not read Retu revision: %d\n", ret);
+ goto error;
+ }
+
+ dev_info(rdev->dev, "Retu%s v%d.%d found\n",
+ (ret & RETU_REG_ASICR_VILMA) ? " & Vilma" : "",
+ (ret >> 4) & 0x7, ret & 0xf);
+
+ ret = irq_alloc_descs(-1, 0, RETU_MAX_IRQ_HANDLERS, 0);
+ if (ret < 0) {
+ dev_err(rdev->dev, "failed to allocate IRQ descs: %d\n", ret);
+ goto error;
+ }
+ rdev->irq_base = ret;
+ rdev->irq_end = ret + RETU_MAX_IRQ_HANDLERS;
+
+ retu_irq_init(rdev);
+
+ ret = request_threaded_irq(rdev->i2c->irq, NULL, retu_irq_handler,
+ IRQF_ONESHOT, "retu-mfd", rdev);
+ if (ret < 0) {
+ dev_err(rdev->dev, "unable to register IRQ handler: %d\n", ret);
+ goto error_irq;
+ }
+ irq_set_irq_wake(rdev->i2c->irq, 1);
+
+ ret = mfd_add_devices(rdev->dev, -1, retu_devs, ARRAY_SIZE(retu_devs),
+ NULL, rdev->irq_base);
+ if (ret < 0)
+ goto error_add;
+
+ if (!pm_power_off) {
+ pm_power_off = retu_power_off;
+ retu_pm_power_off = rdev;
+ }
+
+ return 0;
+
+error_add:
+ free_irq(rdev->i2c->irq, rdev);
+error_irq:
+ irq_free_descs(rdev->irq_base, RETU_MAX_IRQ_HANDLERS);
+error:
+ kfree(rdev);
+ return ret;
+}
+
+static int __devexit retu_remove(struct i2c_client *i2c)
+{
+ struct retu_dev *rdev = i2c_get_clientdata(i2c);
+
+ if (retu_pm_power_off == rdev) {
+ pm_power_off = NULL;
+ retu_pm_power_off = NULL;
+ }
+ free_irq(rdev->i2c->irq, rdev);
+ retu_irq_exit(rdev);
+ irq_free_descs(rdev->irq_base, RETU_MAX_IRQ_HANDLERS);
+ mfd_remove_devices(rdev->dev);
+ kfree(rdev);
+
+ return 0;
+}
+
+static const struct i2c_device_id retu_id[] = {
+ { "retu-mfd", 0 },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, retu_id);
+
+static struct i2c_driver retu_driver = {
+ .driver = {
+ .name = "retu-mfd",
+ .owner = THIS_MODULE,
+ },
+ .probe = retu_probe,
+ .remove = retu_remove,
+ .id_table = retu_id,
+};
+module_i2c_driver(retu_driver);
+
+MODULE_DESCRIPTION("Retu MFD driver");
+MODULE_AUTHOR("Juha Yrjölä");
+MODULE_AUTHOR("David Weinehall");
+MODULE_AUTHOR("Mikko Ylinen");
+MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@....fi>");
+MODULE_LICENSE("GPL");
diff --git a/include/linux/mfd/retu.h b/include/linux/mfd/retu.h
new file mode 100644
index 0000000..1e2715d
--- /dev/null
+++ b/include/linux/mfd/retu.h
@@ -0,0 +1,22 @@
+/*
+ * Retu MFD driver interface
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of this
+ * archive for more details.
+ */
+
+#ifndef __LINUX_MFD_RETU_H
+#define __LINUX_MFD_RETU_H
+
+struct retu_dev;
+
+int retu_read(struct retu_dev *, u8);
+int retu_write(struct retu_dev *, u8, u16);
+
+/* Registers */
+#define RETU_REG_WATCHDOG 0x17 /* Watchdog */
+#define RETU_REG_CC1 0x0d /* Common control register 1 */
+#define RETU_REG_STATUS 0x16 /* Status register */
+
+#endif /* __LINUX_MFD_RETU_H */
--
1.7.2.5
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Powered by blists - more mailing lists