UPSTREAM: nvmem: core: remove regmap dependency

[firefly-linux-kernel-4.4.55.git] / drivers / mfd / wm831x-spi-a22.c

diff --git a/drivers/mfd/wm831x-spi-a22.c b/drivers/mfd/wm831x-spi-a22.c
index 9e7d9cc0b67d5889137a061f06a1afb893ee40fc..392faf002fffe36235687c8a2027d515387a764f 100755 (executable)
--- a/drivers/mfd/wm831x-spi-a22.c
+++ b/drivers/mfd/wm831x-spi-a22.c
@@ -532,76 +532,63 @@ static int wm831x_init(struct wm831x *wm831x)
        
 }
 
+extern void rk29_send_power_key(int state);
+static int gNumInt = 0, gNumTimer = 0;
+static struct timer_list       irq_timer;
+static struct wm831x *gwm831x;
 
-struct wm831x_on {
-       struct input_dev *dev;
-       struct delayed_work work;
-       struct wm831x *wm831x;
-       struct wake_lock        wm831x_on_wake;
-};
-
-static struct wm831x_on *g_wm831x_on;
+void wm831x_power_off(void)
+{
+       wm831x_reg_write(gwm831x, WM831X_POWER_STATE, 0);//power off
+}
 
-void rk29_send_wakeup_key(void)
+static void wm831x_irq_timer(unsigned long data)
 {
-     
-       if(!g_wm831x_on)
+       struct wm831x *wm831x = (struct wm831x *)data;
+       int pin = irq_to_gpio(wm831x->irq);
+
+       if(gNumInt >0)
        {
-               printk("%s:addr err!\n",__FUNCTION__);
-               return;
+               if(gpio_get_value(pin) > 0)     
+               gNumTimer++;
+               else
+               gNumTimer = 0;
+
+               if(gNumTimer >20)
+               {
+                       rk29_send_power_key(0);
+                       gNumTimer = 0;
+                       gNumInt = 0;
+               }
        }
-        input_report_key(g_wm831x_on->dev, KEY_POWER, 1);
-        input_sync(g_wm831x_on->dev);
-        input_report_key(g_wm831x_on->dev, KEY_POWER, 0);
-        input_sync(g_wm831x_on->dev);
-       //printk("%s\n", __FUNCTION__);
-}
+               
+       irq_timer.expires  = jiffies + msecs_to_jiffies(20);
+       add_timer(&irq_timer);
 
+}
 
 static void wm831x_irq_worker(struct work_struct *work)
 {
        struct wm831x *wm831x = container_of(work, struct wm831x, irq_work);    
-       
        wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_1, 0xffff);//clear all intterupt
-       rk29_send_wakeup_key();
-       //enable_irq(wm831x->irq);      
+       gNumInt++;
+       rk29_send_power_key(1);
+       enable_irq(wm831x->irq);        
        wake_unlock(&wm831x->irq_wake);
-       printk("%s\n",__FUNCTION__);
+       //printk("%s,irq=%d\n",__FUNCTION__,wm831x->irq);
 }
 
 static irqreturn_t wm831x_irq_thread(int irq, void *data)
 {
        struct wm831x *wm831x = data;
 
-       //disable_irq_nosync(irq);
+       disable_irq_nosync(irq);
        wake_lock(&wm831x->irq_wake);
        queue_work(wm831x->irq_wq, &wm831x->irq_work);
 
        return IRQ_HANDLED;
 }
 
-static struct platform_driver wm831x_on_driver = {
-       .driver         = {
-               .name   = "wm831x-on",
-       },
-};
-
-static struct platform_device wm831x_on_device = {
-       .name           = "wm831x-on",
-       .id             = -1,
-       .dev = {
-               .driver = &wm831x_on_driver.driver,
-       }
-       
-};
-
-static inline void wm831x_on_init(void)
-{
-       if (platform_driver_register(&wm831x_on_driver) == 0)
-       (void) platform_device_register(&wm831x_on_device);
-}
-
-
 static int __devinit wm831x_spi_probe(struct spi_device *spi)
 {
        struct wm831x *wm831x;
@@ -651,42 +638,10 @@ static int __devinit wm831x_spi_probe(struct spi_device *spi)
        wm831x->control_data = spi;
        wm831x->read_dev = wm831x_spi_read_device;
        wm831x->write_dev = wm831x_spi_write_device;
-
+       gwm831x = wm831x;
        mutex_init(&wm831x->io_lock);
        
        wm831x_init(wm831x);
-       //wm831x_device_init(wm831x, type, irq);
-       
-       dev_set_drvdata(wm831x->dev, wm831x);
-       wm831x_on_init();
-
-       g_wm831x_on = kzalloc(sizeof(struct wm831x_on), GFP_KERNEL);
-       if (!g_wm831x_on) {
-               printk( "Can't allocate data\n");
-               return -ENOMEM;
-       }
-       
-       g_wm831x_on->wm831x = wm831x;
-       g_wm831x_on->dev = input_allocate_device();
-       if (!g_wm831x_on->dev) {
-               //dev_err(&wm831x->dev, "Can't allocate input dev\n");
-               return  -ENOMEM;
-       }
-
-       g_wm831x_on->dev->evbit[0] = BIT_MASK(EV_KEY);
-       g_wm831x_on->dev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
-       g_wm831x_on->dev->name = "wm831x_on";
-       g_wm831x_on->dev->phys = "wm831x_on/input0";
-#if 0
-       g_wm831x_on->dev->dev.parent = &wm831x_on_device.dev;
-       dev_err(&wm831x_on_device.dev, "%s\n", __FUNCTION__);
-       ret = input_register_device(g_wm831x_on->dev);
-       if (ret) {
-               printk( "Can't register input device: %d\n");
-               return  -ENOMEM;
-       }
-       
-#endif
        
        wm831x->irq_wq = create_singlethread_workqueue("wm831x-irq");
        if (!wm831x->irq_wq) {
@@ -698,19 +653,23 @@ static int __devinit wm831x_spi_probe(struct spi_device *spi)
        wake_lock_init(&wm831x->irq_wake, WAKE_LOCK_SUSPEND, "wm831x_irq_wake");
 
        ret = request_threaded_irq(irq, wm831x_irq_thread, NULL, 
-                                IRQF_TRIGGER_FALLING,
+                                IRQF_TRIGGER_LOW,
                                   "wm831x", wm831x);
        if (ret != 0) {
                dev_err(wm831x->dev, "Failed to request IRQ %d: %d\n",
                        wm831x->irq, ret);
                return ret;
        }
-
+       wm831x->irq = irq;
        enable_irq_wake(irq); // so wm831x irq can wake up system
        /* only support on intterupt */
        wm831x_reg_write(wm831x, WM831X_SYSTEM_INTERRUPTS_MASK, 0xefff);
        wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_1_MASK, 0xefff);
 
+       setup_timer(&irq_timer, wm831x_irq_timer, (unsigned long)wm831x);
+       irq_timer.expires  = jiffies+2000;
+       add_timer(&irq_timer);
+
        return 0;
        //return wm831x_device_init(wm831x, type, irq);
 }
@@ -731,6 +690,11 @@ static int wm831x_spi_suspend(struct spi_device *spi, pm_message_t m)
        //return wm831x_device_suspend(wm831x);
 }
 
+static int wm831x_spi_resume(struct spi_device *spi)
+{
+       return 0;
+}
+
 static struct spi_driver wm8310_spi_driver = {
        .driver = {
                .name   = "wm8310",
@@ -740,6 +704,7 @@ static struct spi_driver wm8310_spi_driver = {
        .probe          = wm831x_spi_probe,
        .remove         = __devexit_p(wm831x_spi_remove),
        .suspend        = wm831x_spi_suspend,
+       .resume = wm831x_spi_resume,
 };
 
 static struct spi_driver wm8311_spi_driver = {