Attachment #17822 for bug #11309




		if (wait_event_timeout(ec->wait, acpi_ec_check_status(ec, event),
				       msecs_to_jiffies(ACPI_EC_DELAY)))
			return 0;
		/* Check whether the bogus timeout happens */
		if (!test_bit(EC_FLAGS_WAIT_GPE, &ec->flags) &&
			acpi_ec_check_status(ec, event))
			return 0;

		clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
		if (acpi_ec_check_status(ec, event)) {
			/*
			 * Clear GPE mode flags. When EC internal register is
			 * accessed, EC driver will work in polling mode.
			 * But GPE is still enabled.
			 */
			clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
			return 0;
		}
	} else {

			pr_err(PREFIX "read timeout, command = %d\n", command);
			goto end;
		}

		if (rdata_len > 1)
			set_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
		*(rdata++) = acpi_ec_read_data(ec);
	}
      end:

		ec_switch_to_poll_mode(ec);
		goto end;
	}

	clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
	if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags))
		wake_up(&ec->wait);

		if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
			status = acpi_os_execute(OSL_EC_BURST_HANDLER,
				acpi_ec_gpe_query, ec);
	} else if (!test_bit(EC_FLAGS_GPE_MODE, &ec->flags) &&
		   !test_bit(EC_FLAGS_NO_GPE, &ec->flags) &&
		   in_interrupt()) {
		/* this is non-query, must be confirmation */
		if (printk_ratelimit())
			pr_info(PREFIX "non-query interrupt received,"
				" switching to interrupt mode\n");
		set_bit(EC_FLAGS_GPE_MODE, &ec->flags);
		clear_bit(EC_FLAGS_RESCHEDULE_POLL, &ec->flags);
	}
end:
	ec_schedule_ec_poll(ec);

	if (!ec)
		return NULL;
	ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
	/*
	 * Start GPE mode.
	 * When EC driver is started, it will work in GPE mode.
	 * It means that the EC GPE interrupt is expected when EC status is
	 * changed.
	 * Of course if there is no EC GPE interrupt in some EC transaction,
	 * it will be cleared and EC will work in polling mode when EC
	 * internal register is accessed.
	 */
	set_bit(EC_FLAGS_GPE_MODE, &ec->flags);
	mutex_init(&ec->lock);
	init_waitqueue_head(&ec->wait);
	INIT_LIST_HEAD(&ec->list);

	return AE_CTRL_TERMINATE;
}

static void ec_poll_stop(struct acpi_ec *ec)
{
	clear_bit(EC_FLAGS_RESCHEDULE_POLL, &ec->flags);
	cancel_delayed_work(&ec->work);
}

static void ec_remove_handlers(struct acpi_ec *ec)
{
	ec_poll_stop(ec);
	if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
				ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
		pr_err(PREFIX "failed to remove space handler\n");


	/* EC is fully operational, allow queries */
	clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
	ec_schedule_ec_poll(ec);
	return ret;
}


{
	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, ACPI_NOT_ISR);
	return 0;
}

{
	struct acpi_ec *ec = acpi_driver_data(device);
	/* Enable use of GPE back */
	clear_bit(EC_FLAGS_NO_GPE, &ec->flags);
	acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
	return 0;
}

Return to bug 11309

Lines 203-216 static int acpi_ec_wait(struct acpi_ec * Link Here

(-)linux-2.6/drivers/acpi/ec.c (-28 / +23 lines)
203	if (wait_event_timeout(ec->wait, acpi_ec_check_status(ec, event),	203	if (wait_event_timeout(ec->wait, acpi_ec_check_status(ec, event),
204	msecs_to_jiffies(ACPI_EC_DELAY)))	204	msecs_to_jiffies(ACPI_EC_DELAY)))
205	return 0;	205	return 0;
		206	/* Check whether the bogus timeout happens */
		207	if (!test_bit(EC_FLAGS_WAIT_GPE, &ec->flags) &&
		208	acpi_ec_check_status(ec, event))
		209	return 0;
		210
206	clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags);	211	clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
207	if (acpi_ec_check_status(ec, event)) {	212	if (acpi_ec_check_status(ec, event)) {
208	/* missing GPEs, switch back to poll mode */	213	/*
209	if (printk_ratelimit())	214	* Clear GPE mode flags. When EC internal register is
210	pr_info(PREFIX "missing confirmations, "	215	* accessed, EC driver will work in polling mode.
211	"switch off interrupt mode.\n");	216	* But GPE is still enabled.
212	ec_switch_to_poll_mode(ec);	217	*/
213	ec_schedule_ec_poll(ec);	218	clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
214	return 0;	219	return 0;
215	}	220	}
216	} else {	221	} else {
Lines 265-273 static int acpi_ec_transaction_unlocked( Link Here
265	pr_err(PREFIX "read timeout, command = %d\n", command);	270	pr_err(PREFIX "read timeout, command = %d\n", command);
266	goto end;	271	goto end;
267	}	272	}
268	/* Don't expect GPE after last read */	273
269	if (rdata_len > 1)
270	set_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
271	*(rdata++) = acpi_ec_read_data(ec);	274	*(rdata++) = acpi_ec_read_data(ec);
272	}	275	}
273	end:	276	end:
Lines 541-546 static u32 acpi_ec_gpe_handler(void *dat Link Here
541	ec_switch_to_poll_mode(ec);	544	ec_switch_to_poll_mode(ec);
542	goto end;	545	goto end;
543	}	546	}
		547
544	clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags);	548	clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
545	if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags))	549	if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags))
546	wake_up(&ec->wait);	550	wake_up(&ec->wait);
Lines 549-563 static u32 acpi_ec_gpe_handler(void *dat Link Here
549	if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))	553	if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
550	status = acpi_os_execute(OSL_EC_BURST_HANDLER,	554	status = acpi_os_execute(OSL_EC_BURST_HANDLER,
551	acpi_ec_gpe_query, ec);	555	acpi_ec_gpe_query, ec);
552	} else if (!test_bit(EC_FLAGS_GPE_MODE, &ec->flags) &&
553	!test_bit(EC_FLAGS_NO_GPE, &ec->flags) &&
554	in_interrupt()) {
555	/* this is non-query, must be confirmation */
556	if (printk_ratelimit())
557	pr_info(PREFIX "non-query interrupt received,"
558	" switching to interrupt mode\n");
559	set_bit(EC_FLAGS_GPE_MODE, &ec->flags);
560	clear_bit(EC_FLAGS_RESCHEDULE_POLL, &ec->flags);
561	}	556	}
562	end:	557	end:
563	ec_schedule_ec_poll(ec);	558	ec_schedule_ec_poll(ec);
Lines 710-715 static struct acpi_ec *make_acpi_ec(void Link Here
710	if (!ec)	705	if (!ec)
711	return NULL;	706	return NULL;
712	ec->flags = 1 << EC_FLAGS_QUERY_PENDING;	707	ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
		708	/*
		709	* Start GPE mode.
		710	* When EC driver is started, it will work in GPE mode.
		711	* It means that the EC GPE interrupt is expected when EC status is
		712	* changed.
		713	* Of course if there is no EC GPE interrupt in some EC transaction,
		714	* it will be cleared and EC will work in polling mode when EC
		715	* internal register is accessed.
		716	*/
		717	set_bit(EC_FLAGS_GPE_MODE, &ec->flags);
713	mutex_init(&ec->lock);	718	mutex_init(&ec->lock);
714	init_waitqueue_head(&ec->wait);	719	init_waitqueue_head(&ec->wait);
715	INIT_LIST_HEAD(&ec->list);	720	INIT_LIST_HEAD(&ec->list);
Lines 753-767 ec_parse_device(acpi_handle handle, u32 Link Here
753	return AE_CTRL_TERMINATE;	758	return AE_CTRL_TERMINATE;
754	}	759	}
755		760
756	static void ec_poll_stop(struct acpi_ec *ec)
757	{
758	clear_bit(EC_FLAGS_RESCHEDULE_POLL, &ec->flags);
759	cancel_delayed_work(&ec->work);
760	}
761		761
762	static void ec_remove_handlers(struct acpi_ec *ec)	762	static void ec_remove_handlers(struct acpi_ec *ec)
763	{	763	{
764	ec_poll_stop(ec);
765	if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,	764	if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
766	ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))	765	ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
767	pr_err(PREFIX "failed to remove space handler\n");	766	pr_err(PREFIX "failed to remove space handler\n");
Lines 904-910 static int acpi_ec_start(struct acpi_dev Link Here
904		903
905	/* EC is fully operational, allow queries */	904	/* EC is fully operational, allow queries */
906	clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);	905	clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
907	ec_schedule_ec_poll(ec);
908	return ret;	906	return ret;
909	}	907	}
910		908
Lines 1000-1007 static int acpi_ec_suspend(struct acpi_d Link Here
1000	{	998	{
1001	struct acpi_ec *ec = acpi_driver_data(device);	999	struct acpi_ec *ec = acpi_driver_data(device);
1002	/* Stop using GPE */	1000	/* Stop using GPE */
1003	set_bit(EC_FLAGS_NO_GPE, &ec->flags);
1004	clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
1005	acpi_disable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);	1001	acpi_disable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
1006	return 0;	1002	return 0;
1007	}	1003	}
Lines 1010-1016 static int acpi_ec_resume(struct acpi_de Link Here
1010	{	1006	{
1011	struct acpi_ec *ec = acpi_driver_data(device);	1007	struct acpi_ec *ec = acpi_driver_data(device);
1012	/* Enable use of GPE back */	1008	/* Enable use of GPE back */
1013	clear_bit(EC_FLAGS_NO_GPE, &ec->flags);
1014	acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);	1009	acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);
1015	return 0;	1010	return 0;
1016	}	1011	}