Merge tag 'v3.9-rc3' into next

Merge with mainline to bring in module_platform_driver_probe() and
devm_ioremap_resource().

7 files changed, 284 insertions, 24 deletions

diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index 3ec8887ce451..af80928a46b4 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -72,6 +72,16 @@ config INPUT_AD714X_SPI
           To compile this driver as a module, choose M here: the
           module will be called ad714x-spi.
 
+config INPUT_ARIZONA_HAPTICS
+        tristate "Arizona haptics support"
+        depends on MFD_ARIZONA && SND_SOC
+        select INPUT_FF_MEMLESS
+        help
+          Say Y to enable support for the haptics module in Arizona CODECs.
+
+          To compile this driver as a module, choose M here: the
+          module will be called arizona-haptics.
+
 config INPUT_BMA150
         tristate "BMA150/SMB380 acceleration sensor support"
         depends on I2C
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index d6873433ba71..d7fc17f11d77 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_INPUT_ADXL34X)		+= adxl34x.o
 obj-$(CONFIG_INPUT_ADXL34X_I2C)         += adxl34x-i2c.o
 obj-$(CONFIG_INPUT_ADXL34X_SPI)         += adxl34x-spi.o
 obj-$(CONFIG_INPUT_APANEL)              += apanel.o
+obj-$(CONFIG_INPUT_ARIZONA_HAPTICS)     += arizona-haptics.o
 obj-$(CONFIG_INPUT_ATI_REMOTE2)         += ati_remote2.o
 obj-$(CONFIG_INPUT_ATLAS_BTNS)          += atlas_btns.o
 obj-$(CONFIG_INPUT_BFIN_ROTARY)         += bfin_rotary.o
diff --git a/drivers/input/misc/arizona-haptics.c b/drivers/input/misc/arizona-haptics.c
new file mode 100644
index 000000000000..7a04f54ef961
--- /dev/null
+++ b/drivers/input/misc/arizona-haptics.c
@@ -0,0 +1,255 @@
+/*
+ * Arizona haptics driver
+ *
+ * Copyright 2012 Wolfson Microelectronics plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+#include <linux/mfd/arizona/core.h>
+#include <linux/mfd/arizona/pdata.h>
+#include <linux/mfd/arizona/registers.h>
+
+struct arizona_haptics {
+        struct arizona *arizona;
+        struct input_dev *input_dev;
+        struct work_struct work;
+
+        struct mutex mutex;
+        u8 intensity;
+};
+
+static void arizona_haptics_work(struct work_struct *work)
+{
+        struct arizona_haptics *haptics = container_of(work,
+                                                       struct arizona_haptics,
+                                                       work);
+        struct arizona *arizona = haptics->arizona;
+        struct mutex *dapm_mutex = &arizona->dapm->card->dapm_mutex;
+        int ret;
+
+        if (!haptics->arizona->dapm) {
+                dev_err(arizona->dev, "No DAPM context\n");
+                return;
+        }
+
+        if (haptics->intensity) {
+                ret = regmap_update_bits(arizona->regmap,
+                                         ARIZONA_HAPTICS_PHASE_2_INTENSITY,
+                                         ARIZONA_PHASE2_INTENSITY_MASK,
+                                         haptics->intensity);
+                if (ret != 0) {
+                        dev_err(arizona->dev, "Failed to set intensity: %d\n",
+                                ret);
+                        return;
+                }
+
+                /* This enable sequence will be a noop if already enabled */
+                ret = regmap_update_bits(arizona->regmap,
+                                         ARIZONA_HAPTICS_CONTROL_1,
+                                         ARIZONA_HAP_CTRL_MASK,
+                                         1 << ARIZONA_HAP_CTRL_SHIFT);
+                if (ret != 0) {
+                        dev_err(arizona->dev, "Failed to start haptics: %d\n",
+                                ret);
+                        return;
+                }
+
+                mutex_lock_nested(dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
+
+                ret = snd_soc_dapm_enable_pin(arizona->dapm, "HAPTICS");
+                if (ret != 0) {
+                        dev_err(arizona->dev, "Failed to start HAPTICS: %d\n",
+                                ret);
+                        mutex_unlock(dapm_mutex);
+                        return;
+                }
+
+                ret = snd_soc_dapm_sync(arizona->dapm);
+                if (ret != 0) {
+                        dev_err(arizona->dev, "Failed to sync DAPM: %d\n",
+                                ret);
+                        mutex_unlock(dapm_mutex);
+                        return;
+                }
+
+                mutex_unlock(dapm_mutex);
+
+        } else {
+                /* This disable sequence will be a noop if already enabled */
+                mutex_lock_nested(dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
+
+                ret = snd_soc_dapm_disable_pin(arizona->dapm, "HAPTICS");
+                if (ret != 0) {
+                        dev_err(arizona->dev, "Failed to disable HAPTICS: %d\n",
+                                ret);
+                        mutex_unlock(dapm_mutex);
+                        return;
+                }
+
+                ret = snd_soc_dapm_sync(arizona->dapm);
+                if (ret != 0) {
+                        dev_err(arizona->dev, "Failed to sync DAPM: %d\n",
+                                ret);
+                        mutex_unlock(dapm_mutex);
+                        return;
+                }
+
+                mutex_unlock(dapm_mutex);
+
+                ret = regmap_update_bits(arizona->regmap,
+                                         ARIZONA_HAPTICS_CONTROL_1,
+                                         ARIZONA_HAP_CTRL_MASK,
+                                         1 << ARIZONA_HAP_CTRL_SHIFT);
+                if (ret != 0) {
+                        dev_err(arizona->dev, "Failed to stop haptics: %d\n",
+                                ret);
+                        return;
+                }
+        }
+}
+
+static int arizona_haptics_play(struct input_dev *input, void *data,
+                                struct ff_effect *effect)
+{
+        struct arizona_haptics *haptics = input_get_drvdata(input);
+        struct arizona *arizona = haptics->arizona;
+
+        if (!arizona->dapm) {
+                dev_err(arizona->dev, "No DAPM context\n");
+                return -EBUSY;
+        }
+
+        if (effect->u.rumble.strong_magnitude) {
+                /* Scale the magnitude into the range the device supports */
+                if (arizona->pdata.hap_act) {
+                        haptics->intensity =
+                                effect->u.rumble.strong_magnitude >> 9;
+                        if (effect->direction < 0x8000)
+                                haptics->intensity += 0x7f;
+                } else {
+                        haptics->intensity =
+                                effect->u.rumble.strong_magnitude >> 8;
+                }
+        } else {
+                haptics->intensity = 0;
+        }
+
+        schedule_work(&haptics->work);
+
+        return 0;
+}
+
+static void arizona_haptics_close(struct input_dev *input)
+{
+        struct arizona_haptics *haptics = input_get_drvdata(input);
+        struct mutex *dapm_mutex = &haptics->arizona->dapm->card->dapm_mutex;
+
+        cancel_work_sync(&haptics->work);
+
+        mutex_lock_nested(dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
+
+        if (haptics->arizona->dapm)
+                snd_soc_dapm_disable_pin(haptics->arizona->dapm, "HAPTICS");
+
+        mutex_unlock(dapm_mutex);
+}
+
+static int arizona_haptics_probe(struct platform_device *pdev)
+{
+        struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
+        struct arizona_haptics *haptics;
+        int ret;
+
+        haptics = devm_kzalloc(&pdev->dev, sizeof(*haptics), GFP_KERNEL);
+        if (!haptics)
+                return -ENOMEM;
+
+        haptics->arizona = arizona;
+
+        ret = regmap_update_bits(arizona->regmap, ARIZONA_HAPTICS_CONTROL_1,
+                                 ARIZONA_HAP_ACT, arizona->pdata.hap_act);
+        if (ret != 0) {
+                dev_err(arizona->dev, "Failed to set haptics actuator: %d\n",
+                        ret);
+                return ret;
+        }
+
+        INIT_WORK(&haptics->work, arizona_haptics_work);
+
+        haptics->input_dev = input_allocate_device();
+        if (haptics->input_dev == NULL) {
+                dev_err(arizona->dev, "Failed to allocate input device\n");
+                return -ENOMEM;
+        }
+
+        input_set_drvdata(haptics->input_dev, haptics);
+
+        haptics->input_dev->name = "arizona:haptics";
+        haptics->input_dev->dev.parent = pdev->dev.parent;
+        haptics->input_dev->close = arizona_haptics_close;
+        __set_bit(FF_RUMBLE, haptics->input_dev->ffbit);
+
+        ret = input_ff_create_memless(haptics->input_dev, NULL,
+                                      arizona_haptics_play);
+        if (ret < 0) {
+                dev_err(arizona->dev, "input_ff_create_memless() failed: %d\n",
+                        ret);
+                goto err_ialloc;
+        }
+
+        ret = input_register_device(haptics->input_dev);
+        if (ret < 0) {
+                dev_err(arizona->dev, "couldn't register input device: %d\n",
+                        ret);
+                goto err_iff;
+        }
+
+        platform_set_drvdata(pdev, haptics);
+
+        return 0;
+
+err_iff:
+        if (haptics->input_dev)
+                input_ff_destroy(haptics->input_dev);
+err_ialloc:
+        input_free_device(haptics->input_dev);
+
+        return ret;
+}
+
+static int arizona_haptics_remove(struct platform_device *pdev)
+{
+        struct arizona_haptics *haptics = platform_get_drvdata(pdev);
+
+        input_unregister_device(haptics->input_dev);
+
+        return 0;
+}
+
+static struct platform_driver arizona_haptics_driver = {
+        .probe          = arizona_haptics_probe,
+        .remove         = arizona_haptics_remove,
+        .driver         = {
+                .name   = "arizona-haptics",
+                .owner  = THIS_MODULE,
+        },
+};
+module_platform_driver(arizona_haptics_driver);
+
+MODULE_ALIAS("platform:arizona-haptics");
+MODULE_DESCRIPTION("Arizona haptics driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
diff --git a/drivers/input/misc/atlas_btns.c b/drivers/input/misc/atlas_btns.c
index 26f13131639a..5d4402365a52 100644
--- a/drivers/input/misc/atlas_btns.c
+++ b/drivers/input/misc/atlas_btns.c
@@ -121,7 +121,7 @@ static int atlas_acpi_button_add(struct acpi_device *device)
         return err;
 }
 
-static int atlas_acpi_button_remove(struct acpi_device *device, int type)
+static int atlas_acpi_button_remove(struct acpi_device *device)
 {
         acpi_status status;
 
diff --git a/drivers/input/misc/da9052_onkey.c b/drivers/input/misc/da9052_onkey.c
index 630c1ce4980a..020569a499f2 100644
--- a/drivers/input/misc/da9052_onkey.c
+++ b/drivers/input/misc/da9052_onkey.c
@@ -24,7 +24,6 @@ struct da9052_onkey {
         struct da9052 *da9052;
         struct input_dev *input;
         struct delayed_work work;
-        unsigned int irq;
 };
 
 static void da9052_onkey_query(struct da9052_onkey *onkey)
@@ -76,7 +75,6 @@ static int da9052_onkey_probe(struct platform_device *pdev)
         struct da9052 *da9052 = dev_get_drvdata(pdev->dev.parent);
         struct da9052_onkey *onkey;
         struct input_dev *input_dev;
-        int irq;
         int error;
 
         if (!da9052) {
@@ -84,13 +82,6 @@ static int da9052_onkey_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        irq = platform_get_irq_byname(pdev, "ONKEY");
-        if (irq < 0) {
-                dev_err(&pdev->dev,
-                        "Failed to get an IRQ for input device, %d\n", irq);
-                return -EINVAL;
-        }
-
         onkey = kzalloc(sizeof(*onkey), GFP_KERNEL);
         input_dev = input_allocate_device();
         if (!onkey || !input_dev) {
@@ -101,7 +92,6 @@ static int da9052_onkey_probe(struct platform_device *pdev)
 
         onkey->input = input_dev;
         onkey->da9052 = da9052;
-        onkey->irq = irq;
         INIT_DELAYED_WORK(&onkey->work, da9052_onkey_work);
 
         input_dev->name = "da9052-onkey";
@@ -111,13 +101,11 @@ static int da9052_onkey_probe(struct platform_device *pdev)
         input_dev->evbit[0] = BIT_MASK(EV_KEY);
         __set_bit(KEY_POWER, input_dev->keybit);
 
-        error = request_threaded_irq(onkey->irq, NULL, da9052_onkey_irq,
-                                     IRQF_TRIGGER_LOW | IRQF_ONESHOT,
-                                     "ONKEY", onkey);
+        error = da9052_request_irq(onkey->da9052, DA9052_IRQ_NONKEY, "ONKEY",
+                            da9052_onkey_irq, onkey);
         if (error < 0) {
                 dev_err(onkey->da9052->dev,
-                        "Failed to register ONKEY IRQ %d, error = %d\n",
-                        onkey->irq, error);
+                        "Failed to register ONKEY IRQ: %d\n", error);
                 goto err_free_mem;
         }
 
@@ -132,7 +120,7 @@ static int da9052_onkey_probe(struct platform_device *pdev)
         return 0;
 
 err_free_irq:
-        free_irq(onkey->irq, onkey);
+        da9052_free_irq(onkey->da9052, DA9052_IRQ_NONKEY, onkey);
         cancel_delayed_work_sync(&onkey->work);
 err_free_mem:
         input_free_device(input_dev);
@@ -145,7 +133,7 @@ static int da9052_onkey_remove(struct platform_device *pdev)
 {
         struct da9052_onkey *onkey = platform_get_drvdata(pdev);
 
-        free_irq(onkey->irq, onkey);
+        da9052_free_irq(onkey->da9052, DA9052_IRQ_NONKEY, onkey);
         cancel_delayed_work_sync(&onkey->work);
 
         input_unregister_device(onkey->input);
diff --git a/drivers/input/misc/hp_sdc_rtc.c b/drivers/input/misc/hp_sdc_rtc.c
index 0b4f54265f62..2e3334b8f82d 100644
--- a/drivers/input/misc/hp_sdc_rtc.c
+++ b/drivers/input/misc/hp_sdc_rtc.c
@@ -109,7 +109,9 @@ static int hp_sdc_rtc_do_read_bbrtc (struct rtc_time *rtctm)
         
         if (hp_sdc_enqueue_transaction(&t)) return -1;
         
-        down_interruptible(&tsem);  /* Put ourselves to sleep for results. */
+        /* Put ourselves to sleep for results. */
+        if (WARN_ON(down_interruptible(&tsem)))
+                return -1;
         
         /* Check for nonpresence of BBRTC */
         if (!((tseq[83] | tseq[90] | tseq[69] | tseq[76] |
@@ -176,11 +178,16 @@ static int64_t hp_sdc_rtc_read_i8042timer (uint8_t loadcmd, int numreg)
         t.seq =                 tseq;
         t.act.semaphore =       &i8042tregs;
 
-        down_interruptible(&i8042tregs);  /* Sleep if output regs in use. */
+        /* Sleep if output regs in use. */
+        if (WARN_ON(down_interruptible(&i8042tregs)))
+                return -1;
 
         if (hp_sdc_enqueue_transaction(&t)) return -1;
         
-        down_interruptible(&i8042tregs);  /* Sleep until results come back. */
+        /* Sleep until results come back. */
+        if (WARN_ON(down_interruptible(&i8042tregs)))
+                return -1;
+
         up(&i8042tregs);
 
         return (tseq[5] | 
@@ -276,6 +283,7 @@ static inline int hp_sdc_rtc_read_ct(struct timeval *res) {
 }
 
 
+#if 0 /* not used yet */
 /* Set the i8042 real-time clock */
 static int hp_sdc_rtc_set_rt (struct timeval *setto)
 {
@@ -386,6 +394,7 @@ static int hp_sdc_rtc_set_i8042timer (struct timeval *setto, uint8_t setcmd)
         }
         return 0;
 }
+#endif
 
 static ssize_t hp_sdc_rtc_read(struct file *file, char __user *buf,
                                size_t count, loff_t *ppos) {
diff --git a/drivers/input/misc/max8925_onkey.c b/drivers/input/misc/max8925_onkey.c
index 369a39de4ff3..f9179b2585a9 100644
--- a/drivers/input/misc/max8925_onkey.c
+++ b/drivers/input/misc/max8925_onkey.c
@@ -100,9 +100,6 @@ static int max8925_onkey_probe(struct platform_device *pdev)
         input->dev.parent = &pdev->dev;
         input_set_capability(input, EV_KEY, KEY_POWER);
 
-        irq[0] += chip->irq_base;
-        irq[1] += chip->irq_base;
-
         error = request_threaded_irq(irq[0], NULL, max8925_onkey_handler,
                                      IRQF_ONESHOT, "onkey-down", info);
         if (error < 0) {