Patched in Tegra support.

1 files changed, 53 insertions, 92 deletions

diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 354007d490d..b19a18dd994 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -71,6 +71,9 @@ enum ec_command {
 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
 #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_STORM,             /* GPE storm detected */
@@ -84,15 +87,6 @@ static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
 module_param(ec_delay, uint, 0644);
 MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
 
-/*
- * If the number of false interrupts per one transaction exceeds
- * this threshold, will think there is a GPE storm happened and
- * will disable the GPE for normal transaction.
- */
-static unsigned int ec_storm_threshold  __read_mostly = 8;
-module_param(ec_storm_threshold, uint, 0644);
-MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
-
 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
 /* External interfaces use first EC only, so remember */
 typedef int (*acpi_ec_query_func) (void *data);
@@ -158,10 +152,10 @@ static int ec_transaction_done(struct acpi_ec *ec)
 {
         unsigned long flags;
         int ret = 0;
-        spin_lock_irqsave(&ec->lock, flags);
+        spin_lock_irqsave(&ec->curr_lock, flags);
         if (!ec->curr || ec->curr->done)
                 ret = 1;
-        spin_unlock_irqrestore(&ec->lock, flags);
+        spin_unlock_irqrestore(&ec->curr_lock, flags);
         return ret;
 }
 
@@ -175,38 +169,32 @@ static void start_transaction(struct acpi_ec *ec)
 static void advance_transaction(struct acpi_ec *ec, u8 status)
 {
         unsigned long flags;
-        struct transaction *t = ec->curr;
-
-        spin_lock_irqsave(&ec->lock, flags);
-        if (!t)
+        spin_lock_irqsave(&ec->curr_lock, flags);
+        if (!ec->curr)
                 goto unlock;
-        if (t->wlen > t->wi) {
+        if (ec->curr->wlen > ec->curr->wi) {
                 if ((status & ACPI_EC_FLAG_IBF) == 0)
                         acpi_ec_write_data(ec,
-                                t->wdata[t->wi++]);
+                                ec->curr->wdata[ec->curr->wi++]);
                 else
                         goto err;
-        } else if (t->rlen > t->ri) {
+        } else if (ec->curr->rlen > ec->curr->ri) {
                 if ((status & ACPI_EC_FLAG_OBF) == 1) {
-                        t->rdata[t->ri++] = acpi_ec_read_data(ec);
-                        if (t->rlen == t->ri)
-                                t->done = true;
+                        ec->curr->rdata[ec->curr->ri++] = acpi_ec_read_data(ec);
+                        if (ec->curr->rlen == ec->curr->ri)
+                                ec->curr->done = true;
                 } else
                         goto err;
-        } else if (t->wlen == t->wi &&
+        } else if (ec->curr->wlen == ec->curr->wi &&
                    (status & ACPI_EC_FLAG_IBF) == 0)
-                t->done = true;
+                ec->curr->done = true;
         goto unlock;
 err:
-        /*
-         * If SCI bit is set, then don't think it's a false IRQ
-         * otherwise will take a not handled IRQ as a false one.
-         */
-        if (in_interrupt() && !(status & ACPI_EC_FLAG_SCI))
-                ++t->irq_count;
-
+        /* false interrupt, state didn't change */
+        if (in_interrupt())
+                ++ec->curr->irq_count;
 unlock:
-        spin_unlock_irqrestore(&ec->lock, flags);
+        spin_unlock_irqrestore(&ec->curr_lock, flags);
 }
 
 static int acpi_ec_sync_query(struct acpi_ec *ec);
@@ -244,9 +232,9 @@ static int ec_poll(struct acpi_ec *ec)
                 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF)
                         break;
                 pr_debug(PREFIX "controller reset, restart transaction\n");
-                spin_lock_irqsave(&ec->lock, flags);
+                spin_lock_irqsave(&ec->curr_lock, flags);
                 start_transaction(ec);
-                spin_unlock_irqrestore(&ec->lock, flags);
+                spin_unlock_irqrestore(&ec->curr_lock, flags);
         }
         return -ETIME;
 }
@@ -259,17 +247,17 @@ static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
         if (EC_FLAGS_MSI)
                 udelay(ACPI_EC_MSI_UDELAY);
         /* start transaction */
-        spin_lock_irqsave(&ec->lock, tmp);
+        spin_lock_irqsave(&ec->curr_lock, tmp);
         /* following two actions should be kept atomic */
         ec->curr = t;
         start_transaction(ec);
         if (ec->curr->command == ACPI_EC_COMMAND_QUERY)
                 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
-        spin_unlock_irqrestore(&ec->lock, tmp);
+        spin_unlock_irqrestore(&ec->curr_lock, tmp);
         ret = ec_poll(ec);
-        spin_lock_irqsave(&ec->lock, tmp);
+        spin_lock_irqsave(&ec->curr_lock, tmp);
         ec->curr = NULL;
-        spin_unlock_irqrestore(&ec->lock, tmp);
+        spin_unlock_irqrestore(&ec->curr_lock, tmp);
         return ret;
 }
 
@@ -298,7 +286,7 @@ static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
                 return -EINVAL;
         if (t->rdata)
                 memset(t->rdata, 0, t->rlen);
-        mutex_lock(&ec->mutex);
+        mutex_lock(&ec->lock);
         if (test_bit(EC_FLAGS_BLOCKED, &ec->flags)) {
                 status = -EINVAL;
                 goto unlock;
@@ -316,8 +304,7 @@ static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
                 status = -ETIME;
                 goto end;
         }
-        pr_debug(PREFIX "transaction start (cmd=0x%02x, addr=0x%02x)\n",
-                        t->command, t->wdata ? t->wdata[0] : 0);
+        pr_debug(PREFIX "transaction start\n");
         /* disable GPE during transaction if storm is detected */
         if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
                 /* It has to be disabled, so that it doesn't trigger. */
@@ -332,10 +319,9 @@ static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
                 msleep(1);
                 /* It is safe to enable the GPE outside of the transaction. */
                 acpi_enable_gpe(NULL, ec->gpe);
-        } else if (t->irq_count > ec_storm_threshold) {
-                pr_info(PREFIX "GPE storm detected(%d GPEs), "
-                        "transactions will use polling mode\n",
-                        t->irq_count);
+        } 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);
         }
         pr_debug(PREFIX "transaction end\n");
@@ -343,7 +329,7 @@ end:
         if (ec->global_lock)
                 acpi_release_global_lock(glk);
 unlock:
-        mutex_unlock(&ec->mutex);
+        mutex_unlock(&ec->lock);
         return status;
 }
 
@@ -411,7 +397,7 @@ int ec_burst_disable(void)
 
 EXPORT_SYMBOL(ec_burst_disable);
 
-int ec_read(u8 addr, u8 *val)
+int ec_read(u8 addr, u8 * val)
 {
         int err;
         u8 temp_data;
@@ -459,16 +445,6 @@ int ec_transaction(u8 command,
 
 EXPORT_SYMBOL(ec_transaction);
 
-/* Get the handle to the EC device */
-acpi_handle ec_get_handle(void)
-{
-        if (!first_ec)
-                return NULL;
-        return first_ec->handle;
-}
-
-EXPORT_SYMBOL(ec_get_handle);
-
 void acpi_ec_block_transactions(void)
 {
         struct acpi_ec *ec = first_ec;
@@ -476,10 +452,10 @@ void acpi_ec_block_transactions(void)
         if (!ec)
                 return;
 
-        mutex_lock(&ec->mutex);
+        mutex_lock(&ec->lock);
         /* Prevent transactions from being carried out */
         set_bit(EC_FLAGS_BLOCKED, &ec->flags);
-        mutex_unlock(&ec->mutex);
+        mutex_unlock(&ec->lock);
 }
 
 void acpi_ec_unblock_transactions(void)
@@ -489,10 +465,10 @@ void acpi_ec_unblock_transactions(void)
         if (!ec)
                 return;
 
-        mutex_lock(&ec->mutex);
+        mutex_lock(&ec->lock);
         /* Allow transactions to be carried out again */
         clear_bit(EC_FLAGS_BLOCKED, &ec->flags);
-        mutex_unlock(&ec->mutex);
+        mutex_unlock(&ec->lock);
 }
 
 void acpi_ec_unblock_transactions_early(void)
@@ -544,9 +520,9 @@ int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
         handler->handle = handle;
         handler->func = func;
         handler->data = data;
-        mutex_lock(&ec->mutex);
+        mutex_lock(&ec->lock);
         list_add(&handler->node, &ec->list);
-        mutex_unlock(&ec->mutex);
+        mutex_unlock(&ec->lock);
         return 0;
 }
 
@@ -555,14 +531,14 @@ EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
 {
         struct acpi_ec_query_handler *handler, *tmp;
-        mutex_lock(&ec->mutex);
+        mutex_lock(&ec->lock);
         list_for_each_entry_safe(handler, tmp, &ec->list, node) {
                 if (query_bit == handler->query_bit) {
                         list_del(&handler->node);
                         kfree(handler);
                 }
         }
-        mutex_unlock(&ec->mutex);
+        mutex_unlock(&ec->lock);
 }
 
 EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
@@ -609,9 +585,9 @@ static void acpi_ec_gpe_query(void *ec_cxt)
         struct acpi_ec *ec = ec_cxt;
         if (!ec)
                 return;
-        mutex_lock(&ec->mutex);
+        mutex_lock(&ec->lock);
         acpi_ec_sync_query(ec);
-        mutex_unlock(&ec->mutex);
+        mutex_unlock(&ec->lock);
 }
 
 static int ec_check_sci(struct acpi_ec *ec, u8 state)
@@ -630,11 +606,10 @@ static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
         u32 gpe_number, void *data)
 {
         struct acpi_ec *ec = data;
-        u8 status = acpi_ec_read_status(ec);
 
-        pr_debug(PREFIX "~~~> interrupt, status:0x%02x\n", status);
+        pr_debug(PREFIX "~~~> interrupt\n");
 
-        advance_transaction(ec, status);
+        advance_transaction(ec, acpi_ec_read_status(ec));
         if (ec_transaction_done(ec) &&
             (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) == 0) {
                 wake_up(&ec->wait);
@@ -700,10 +675,10 @@ static struct acpi_ec *make_acpi_ec(void)
         if (!ec)
                 return NULL;
         ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
-        mutex_init(&ec->mutex);
+        mutex_init(&ec->lock);
         init_waitqueue_head(&ec->wait);
         INIT_LIST_HEAD(&ec->list);
-        spin_lock_init(&ec->lock);
+        spin_lock_init(&ec->curr_lock);
         return ec;
 }
 
@@ -837,10 +812,10 @@ static int acpi_ec_add(struct acpi_device *device)
                 first_ec = ec;
         device->driver_data = ec;
 
-        ret = !!request_region(ec->data_addr, 1, "EC data");
-        WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
-        ret = !!request_region(ec->command_addr, 1, "EC cmd");
-        WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
+        WARN(!request_region(ec->data_addr, 1, "EC data"),
+             "Could not request EC data io port 0x%lx", ec->data_addr);
+        WARN(!request_region(ec->command_addr, 1, "EC cmd"),
+             "Could not request EC cmd io port 0x%lx", ec->command_addr);
 
         pr_info(PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
                           ec->gpe, ec->command_addr, ec->data_addr);
@@ -862,12 +837,12 @@ static int acpi_ec_remove(struct acpi_device *device, int type)
 
         ec = acpi_driver_data(device);
         ec_remove_handlers(ec);
-        mutex_lock(&ec->mutex);
+        mutex_lock(&ec->lock);
         list_for_each_entry_safe(handler, tmp, &ec->list, node) {
                 list_del(&handler->node);
                 kfree(handler);
         }
-        mutex_unlock(&ec->mutex);
+        mutex_unlock(&ec->lock);
         release_region(ec->data_addr, 1);
         release_region(ec->command_addr, 1);
         device->driver_data = NULL;
@@ -939,17 +914,6 @@ static int ec_flag_msi(const struct dmi_system_id *id)
         return 0;
 }
 
-/*
- * Clevo M720 notebook actually works ok with IRQ mode, if we lifted
- * the GPE storm threshold back to 20
- */
-static int ec_enlarge_storm_threshold(const struct dmi_system_id *id)
-{
-        pr_debug("Setting the EC GPE storm threshold to 20\n");
-        ec_storm_threshold  = 20;
-        return 0;
-}
-
 static struct dmi_system_id __initdata ec_dmi_table[] = {
         {
         ec_skip_dsdt_scan, "Compal JFL92", {
@@ -981,13 +945,10 @@ static struct dmi_system_id __initdata ec_dmi_table[] = {
         {
         ec_validate_ecdt, "ASUS hardware", {
         DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc.") }, NULL},
-        {
-        ec_enlarge_storm_threshold, "CLEVO hardware", {
-        DMI_MATCH(DMI_SYS_VENDOR, "CLEVO Co."),
-        DMI_MATCH(DMI_PRODUCT_NAME, "M720T/M730T"),}, NULL},
         {},
 };
 
+
 int __init acpi_ec_ecdt_probe(void)
 {
         acpi_status status;