Merge branch 'ec' into release

Conflicts:
	drivers/acpi/ec.c

Signed-off-by: Len Brown <len.brown@intel.com>

1 files changed, 50 insertions, 100 deletions

diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index f28619d658f7..08b8cf79946b 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -67,15 +67,13 @@ enum ec_command {
 #define ACPI_EC_DELAY           500     /* Wait 500ms max. during EC ops */
 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
 #define ACPI_EC_CDELAY          10      /* Wait 10us before polling EC */
+#define ACPI_EC_MSI_UDELAY      550     /* Wait 550us for MSI EC */
 
 #define ACPI_EC_STORM_THRESHOLD 8       /* number of false interrupts
                                            per one transaction */
 
 enum {
         EC_FLAGS_QUERY_PENDING,         /* Query is pending */
-        EC_FLAGS_GPE_MODE,              /* Expect GPE to be sent
-                                         * for status change */
-        EC_FLAGS_NO_GPE,                /* Don't use GPE mode */
         EC_FLAGS_GPE_STORM,             /* GPE storm detected */
         EC_FLAGS_HANDLERS_INSTALLED     /* Handlers for GPE and
                                          * OpReg are installed */
@@ -169,7 +167,7 @@ static void start_transaction(struct acpi_ec *ec)
         acpi_ec_write_cmd(ec, ec->curr->command);
 }
 
-static void gpe_transaction(struct acpi_ec *ec, u8 status)
+static void advance_transaction(struct acpi_ec *ec, u8 status)
 {
         unsigned long flags;
         spin_lock_irqsave(&ec->curr_lock, flags);
@@ -200,29 +198,6 @@ unlock:
         spin_unlock_irqrestore(&ec->curr_lock, flags);
 }
 
-static int acpi_ec_wait(struct acpi_ec *ec)
-{
-        if (wait_event_timeout(ec->wait, ec_transaction_done(ec),
-                               msecs_to_jiffies(ACPI_EC_DELAY)))
-                return 0;
-        /* try restart command if we get any false interrupts */
-        if (ec->curr->irq_count &&
-            (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) == 0) {
-                pr_debug(PREFIX "controller reset, restart transaction\n");
-                start_transaction(ec);
-                if (wait_event_timeout(ec->wait, ec_transaction_done(ec),
-                                        msecs_to_jiffies(ACPI_EC_DELAY)))
-                        return 0;
-        }
-        /* missing GPEs, switch back to poll mode */
-        if (printk_ratelimit())
-                pr_info(PREFIX "missing confirmations, "
-                                "switch off interrupt mode.\n");
-        set_bit(EC_FLAGS_NO_GPE, &ec->flags);
-        clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
-        return 1;
-}
-
 static void acpi_ec_gpe_query(void *ec_cxt);
 
 static int ec_check_sci(struct acpi_ec *ec, u8 state)
@@ -235,43 +210,51 @@ static int ec_check_sci(struct acpi_ec *ec, u8 state)
         return 0;
 }
 
-static void ec_delay(void)
-{
-        /* EC in MSI notebooks don't tolerate delays other than 550 usec */
-        if (EC_FLAGS_MSI)
-                udelay(ACPI_EC_DELAY);
-        else
-                /* Use shortest sleep available */
-                msleep(1);
-}
-
 static int ec_poll(struct acpi_ec *ec)
 {
-        unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY);
-        udelay(ACPI_EC_CDELAY);
-        while (time_before(jiffies, delay)) {
-                gpe_transaction(ec, acpi_ec_read_status(ec));
-                ec_delay();
-                if (ec_transaction_done(ec))
-                        return 0;
+        unsigned long flags;
+        int repeat = 2; /* number of command restarts */
+        while (repeat--) {
+                unsigned long delay = jiffies +
+                        msecs_to_jiffies(ACPI_EC_DELAY);
+                do {
+                        /* don't sleep with disabled interrupts */
+                        if (EC_FLAGS_MSI || irqs_disabled()) {
+                                udelay(ACPI_EC_MSI_UDELAY);
+                                if (ec_transaction_done(ec))
+                                        return 0;
+                        } else {
+                                if (wait_event_timeout(ec->wait,
+                                                ec_transaction_done(ec),
+                                                msecs_to_jiffies(1)))
+                                        return 0;
+                        }
+                        advance_transaction(ec, acpi_ec_read_status(ec));
+                } while (time_before(jiffies, delay));
+                if (!ec->curr->irq_count ||
+                    (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF))
+                        break;
+                /* try restart command if we get any false interrupts */
+                pr_debug(PREFIX "controller reset, restart transaction\n");
+                spin_lock_irqsave(&ec->curr_lock, flags);
+                start_transaction(ec);
+                spin_unlock_irqrestore(&ec->curr_lock, flags);
         }
         return -ETIME;
 }
 
 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
-                                        struct transaction *t,
-                                        int force_poll)
+                                        struct transaction *t)
 {
         unsigned long tmp;
         int ret = 0;
         pr_debug(PREFIX "transaction start\n");
         /* disable GPE during transaction if storm is detected */
         if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
-                clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
                 acpi_disable_gpe(NULL, ec->gpe);
         }
         if (EC_FLAGS_MSI)
-                udelay(ACPI_EC_DELAY);
+                udelay(ACPI_EC_MSI_UDELAY);
         /* start transaction */
         spin_lock_irqsave(&ec->curr_lock, tmp);
         /* following two actions should be kept atomic */
@@ -280,11 +263,7 @@ static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
         if (ec->curr->command == ACPI_EC_COMMAND_QUERY)
                 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
         spin_unlock_irqrestore(&ec->curr_lock, tmp);
-        /* if we selected poll mode or failed in GPE-mode do a poll loop */
-        if (force_poll ||
-            !test_bit(EC_FLAGS_GPE_MODE, &ec->flags) ||
-            acpi_ec_wait(ec))
-                ret = ec_poll(ec);
+        ret = ec_poll(ec);
         pr_debug(PREFIX "transaction end\n");
         spin_lock_irqsave(&ec->curr_lock, tmp);
         ec->curr = NULL;
@@ -294,8 +273,7 @@ static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
                 ec_check_sci(ec, acpi_ec_read_status(ec));
                 /* it is safe to enable GPE outside of transaction */
                 acpi_enable_gpe(NULL, ec->gpe);
-        } else if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags) &&
-                   t->irq_count > ACPI_EC_STORM_THRESHOLD) {
+        } else if (t->irq_count > ACPI_EC_STORM_THRESHOLD) {
                 pr_info(PREFIX "GPE storm detected, "
                         "transactions will use polling mode\n");
                 set_bit(EC_FLAGS_GPE_STORM, &ec->flags);
@@ -313,16 +291,14 @@ static int ec_wait_ibf0(struct acpi_ec *ec)
 {
         unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY);
         /* interrupt wait manually if GPE mode is not active */
-        unsigned long timeout = test_bit(EC_FLAGS_GPE_MODE, &ec->flags) ?
-                msecs_to_jiffies(ACPI_EC_DELAY) : msecs_to_jiffies(1);
         while (time_before(jiffies, delay))
-                if (wait_event_timeout(ec->wait, ec_check_ibf0(ec), timeout))
+                if (wait_event_timeout(ec->wait, ec_check_ibf0(ec),
+                                        msecs_to_jiffies(1)))
                         return 0;
         return -ETIME;
 }
 
-static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t,
-                               int force_poll)
+static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
 {
         int status;
         u32 glk;
@@ -344,7 +320,7 @@ static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t,
                 status = -ETIME;
                 goto end;
         }
-        status = acpi_ec_transaction_unlocked(ec, t, force_poll);
+        status = acpi_ec_transaction_unlocked(ec, t);
 end:
         if (ec->global_lock)
                 acpi_release_global_lock(glk);
@@ -353,10 +329,6 @@ unlock:
         return status;
 }
 
-/*
- * Note: samsung nv5000 doesn't work with ec burst mode.
- * http://bugzilla.kernel.org/show_bug.cgi?id=4980
- */
 static int acpi_ec_burst_enable(struct acpi_ec *ec)
 {
         u8 d;
@@ -364,7 +336,7 @@ static int acpi_ec_burst_enable(struct acpi_ec *ec)
                                 .wdata = NULL, .rdata = &d,
                                 .wlen = 0, .rlen = 1};
 
-        return acpi_ec_transaction(ec, &t, 0);
+        return acpi_ec_transaction(ec, &t);
 }
 
 static int acpi_ec_burst_disable(struct acpi_ec *ec)
@@ -374,7 +346,7 @@ static int acpi_ec_burst_disable(struct acpi_ec *ec)
                                 .wlen = 0, .rlen = 0};
 
         return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
-                                acpi_ec_transaction(ec, &t, 0) : 0;
+                                acpi_ec_transaction(ec, &t) : 0;
 }
 
 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data)
@@ -385,7 +357,7 @@ static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data)
                                 .wdata = &address, .rdata = &d,
                                 .wlen = 1, .rlen = 1};
 
-        result = acpi_ec_transaction(ec, &t, 0);
+        result = acpi_ec_transaction(ec, &t);
         *data = d;
         return result;
 }
@@ -397,7 +369,7 @@ static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
                                 .wdata = wdata, .rdata = NULL,
                                 .wlen = 2, .rlen = 0};
 
-        return acpi_ec_transaction(ec, &t, 0);
+        return acpi_ec_transaction(ec, &t);
 }
 
 /*
@@ -465,7 +437,7 @@ int ec_transaction(u8 command,
         if (!first_ec)
                 return -ENODEV;
 
-        return acpi_ec_transaction(first_ec, &t, force_poll);
+        return acpi_ec_transaction(first_ec, &t);
 }
 
 EXPORT_SYMBOL(ec_transaction);
@@ -486,7 +458,7 @@ static int acpi_ec_query(struct acpi_ec *ec, u8 * data)
          * bit to be cleared (and thus clearing the interrupt source).
          */
 
-        result = acpi_ec_transaction(ec, &t, 0);
+        result = acpi_ec_transaction(ec, &t);
         if (result)
                 return result;
 
@@ -569,28 +541,10 @@ static u32 acpi_ec_gpe_handler(void *data)
         pr_debug(PREFIX "~~~> interrupt\n");
         status = acpi_ec_read_status(ec);
 
-        if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags)) {
-                gpe_transaction(ec, status);
-                if (ec_transaction_done(ec) &&
-                    (status & ACPI_EC_FLAG_IBF) == 0)
-                        wake_up(&ec->wait);
-        }
-
+        advance_transaction(ec, status);
+        if (ec_transaction_done(ec) && (status & ACPI_EC_FLAG_IBF) == 0)
+                wake_up(&ec->wait);
         ec_check_sci(ec, status);
-        if (!test_bit(EC_FLAGS_GPE_MODE, &ec->flags) &&
-            !test_bit(EC_FLAGS_NO_GPE, &ec->flags)) {
-                /* this is non-query, must be confirmation */
-                if (!test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
-                        if (printk_ratelimit())
-                                pr_info(PREFIX "non-query interrupt received,"
-                                        " switching to interrupt mode\n");
-                } else {
-                        /* hush, STORM switches the mode every transaction */
-                        pr_debug(PREFIX "non-query interrupt received,"
-                                " switching to interrupt mode\n");
-                }
-                set_bit(EC_FLAGS_GPE_MODE, &ec->flags);
-        }
         return ACPI_INTERRUPT_HANDLED;
 }
 
@@ -616,7 +570,8 @@ acpi_ec_space_handler(u32 function, acpi_physical_address address,
         if (bits != 8 && acpi_strict)
                 return AE_BAD_PARAMETER;
 
-        acpi_ec_burst_enable(ec);
+        if (EC_FLAGS_MSI)
+                acpi_ec_burst_enable(ec);
 
         if (function == ACPI_READ) {
                 result = acpi_ec_read(ec, address, &temp);
@@ -637,7 +592,8 @@ acpi_ec_space_handler(u32 function, acpi_physical_address address,
                 }
         }
 
-        acpi_ec_burst_disable(ec);
+        if (EC_FLAGS_MSI)
+                acpi_ec_burst_disable(ec);
 
         switch (result) {
         case -EINVAL:
@@ -871,8 +827,6 @@ static int acpi_ec_add(struct acpi_device *device)
         acpi_ec_add_fs(device);
         pr_info(PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
                           ec->gpe, ec->command_addr, ec->data_addr);
-        pr_info(PREFIX "driver started in %s mode\n",
-                (test_bit(EC_FLAGS_GPE_MODE, &ec->flags))?"interrupt":"poll");
 
         ret = ec_install_handlers(ec);
 
@@ -1025,8 +979,6 @@ static int acpi_ec_suspend(struct acpi_device *device, pm_message_t state)
 {
         struct acpi_ec *ec = acpi_driver_data(device);
         /* Stop using GPE */
-        set_bit(EC_FLAGS_NO_GPE, &ec->flags);
-        clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
         acpi_disable_gpe(NULL, ec->gpe);
         return 0;
 }
@@ -1035,8 +987,6 @@ static int acpi_ec_resume(struct acpi_device *device)
 {
         struct acpi_ec *ec = acpi_driver_data(device);
         /* Enable use of GPE back */
-        clear_bit(EC_FLAGS_NO_GPE, &ec->flags);
-        set_bit(EC_FLAGS_GPE_MODE, &ec->flags);
         acpi_enable_gpe(NULL, ec->gpe);
         return 0;
 }