ec.c revision ab9e43c640b2b7d6e296fc39dd8cbcb96f9ae393 
1/*
2 *  acpi_ec.c - ACPI Embedded Controller Driver ($Revision: 38 $)
3 *
4 *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
5 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7 *
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 *
10 *  This program is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License as published by
12 *  the Free Software Foundation; either version 2 of the License, or (at
13 *  your option) any later version.
14 *
15 *  This program is distributed in the hope that it will be useful, but
16 *  WITHOUT ANY WARRANTY; without even the implied warranty of
17 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18 *  General Public License for more details.
19 *
20 *  You should have received a copy of the GNU General Public License along
21 *  with this program; if not, write to the Free Software Foundation, Inc.,
22 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 *
24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 */
26
27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/init.h>
30#include <linux/types.h>
31#include <linux/delay.h>
32#include <linux/proc_fs.h>
33#include <linux/seq_file.h>
34#include <linux/interrupt.h>
35#include <asm/io.h>
36#include <acpi/acpi_bus.h>
37#include <acpi/acpi_drivers.h>
38#include <acpi/actypes.h>
39
40#define _COMPONENT		ACPI_EC_COMPONENT
41ACPI_MODULE_NAME("acpi_ec")
42#define ACPI_EC_COMPONENT		0x00100000
43#define ACPI_EC_CLASS			"embedded_controller"
44#define ACPI_EC_HID			"PNP0C09"
45#define ACPI_EC_DRIVER_NAME		"ACPI Embedded Controller Driver"
46#define ACPI_EC_DEVICE_NAME		"Embedded Controller"
47#define ACPI_EC_FILE_INFO		"info"
48
49/* EC status register */
50#define ACPI_EC_FLAG_OBF	0x01	/* Output buffer full */
51#define ACPI_EC_FLAG_IBF	0x02	/* Input buffer full */
52#define ACPI_EC_FLAG_BURST	0x10	/* burst mode */
53#define ACPI_EC_FLAG_SCI	0x20	/* EC-SCI occurred */
54
55/* EC commands */
56#define ACPI_EC_COMMAND_READ	0x80
57#define ACPI_EC_COMMAND_WRITE	0x81
58#define ACPI_EC_BURST_ENABLE	0x82
59#define ACPI_EC_BURST_DISABLE	0x83
60#define ACPI_EC_COMMAND_QUERY	0x84
61
62/* EC events */
63enum {
64	ACPI_EC_EVENT_OBF_1 = 1,	/* Output buffer full */
65	ACPI_EC_EVENT_IBF_0,		/* Input buffer empty */
66};
67
68#define ACPI_EC_DELAY		50	/* Wait 50ms max. during EC ops */
69#define ACPI_EC_UDELAY_GLK	1000	/* Wait 1ms max. to get global lock */
70#define ACPI_EC_UDELAY         100	/* Poll @ 100us increments */
71#define ACPI_EC_UDELAY_COUNT   1000	/* Wait 10ms max. during EC ops */
72
73enum {
74	EC_INTR = 1,	/* Output buffer full */
75	EC_POLL,	/* Input buffer empty */
76};
77
78static int acpi_ec_remove(struct acpi_device *device, int type);
79static int acpi_ec_start(struct acpi_device *device);
80static int acpi_ec_stop(struct acpi_device *device, int type);
81static int acpi_ec_add(struct acpi_device *device);
82
83static struct acpi_driver acpi_ec_driver = {
84	.name = ACPI_EC_DRIVER_NAME,
85	.class = ACPI_EC_CLASS,
86	.ids = ACPI_EC_HID,
87	.ops = {
88		.add = acpi_ec_add,
89		.remove = acpi_ec_remove,
90		.start = acpi_ec_start,
91		.stop = acpi_ec_stop,
92		},
93};
94
95/* If we find an EC via the ECDT, we need to keep a ptr to its context */
96struct acpi_ec {
97	acpi_handle handle;
98	unsigned long uid;
99	unsigned long gpe_bit;
100	unsigned long command_addr;
101	unsigned long data_addr;
102	unsigned long global_lock;
103	struct semaphore sem;
104	unsigned int expect_event;
105	atomic_t leaving_burst;	/* 0 : No, 1 : Yes, 2: abort */
106	wait_queue_head_t wait;
107} *ec_ecdt;
108
109/* External interfaces use first EC only, so remember */
110static struct acpi_device *first_ec;
111static int acpi_ec_mode = EC_INTR;
112
113/* --------------------------------------------------------------------------
114                             Transaction Management
115   -------------------------------------------------------------------------- */
116
117static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
118{
119	return inb(ec->command_addr);
120}
121
122static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
123{
124	return inb(ec->data_addr);
125}
126
127static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
128{
129	outb(command, ec->command_addr);
130}
131
132static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
133{
134	outb(data, ec->data_addr);
135}
136
137static int acpi_ec_check_status(u8 status, u8 event)
138{
139	switch (event) {
140	case ACPI_EC_EVENT_OBF_1:
141		if (status & ACPI_EC_FLAG_OBF)
142			return 1;
143		break;
144	case ACPI_EC_EVENT_IBF_0:
145		if (!(status & ACPI_EC_FLAG_IBF))
146			return 1;
147		break;
148	default:
149		break;
150	}
151
152	return 0;
153}
154
155static int acpi_ec_wait(struct acpi_ec *ec, u8 event)
156{
157	int i = (acpi_ec_mode == EC_POLL) ? ACPI_EC_UDELAY_COUNT : 0;
158	long time_left;
159
160	ec->expect_event = event;
161	if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
162		ec->expect_event = 0;
163		return 0;
164	}
165
166	do {
167		if (acpi_ec_mode == EC_POLL) {
168			udelay(ACPI_EC_UDELAY);
169		} else {
170			time_left = wait_event_timeout(ec->wait,
171				    !ec->expect_event,
172				    msecs_to_jiffies(ACPI_EC_DELAY));
173			if (time_left > 0) {
174				ec->expect_event = 0;
175				return 0;
176			}
177		}
178		if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
179			ec->expect_event = 0;
180			return 0;
181		}
182	} while (--i > 0);
183
184	ec->expect_event = 0;
185
186	return -ETIME;
187}
188
189#ifdef ACPI_FUTURE_USAGE
190/*
191 * Note: samsung nv5000 doesn't work with ec burst mode.
192 * http://bugzilla.kernel.org/show_bug.cgi?id=4980
193 */
194int acpi_ec_enter_burst_mode(struct acpi_ec *ec)
195{
196	u8 tmp = 0;
197	u8 status = 0;
198
199
200	status = acpi_ec_read_status(ec);
201	if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) {
202		status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
203		if (status)
204			goto end;
205		acpi_ec_write_cmd(ec, ACPI_EC_BURST_ENABLE);
206		status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1);
207		tmp = acpi_ec_read_data(ec);
208		if (tmp != 0x90) {	/* Burst ACK byte */
209			return -EINVAL;
210		}
211	}
212
213	atomic_set(&ec->leaving_burst, 0);
214	return 0;
215  end:
216	ACPI_EXCEPTION((AE_INFO, status, "EC wait, burst mode"));
217	return -1;
218}
219
220int acpi_ec_leave_burst_mode(struct acpi_ec *ec)
221{
222	u8 status = 0;
223
224
225	status = acpi_ec_read_status(ec);
226	if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){
227		status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
228		if(status)
229			goto end;
230		acpi_ec_write_cmd(ec, ACPI_EC_BURST_DISABLE);
231		acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
232	}
233	atomic_set(&ec->leaving_burst, 1);
234	return 0;
235  end:
236	ACPI_EXCEPTION((AE_INFO, status, "EC leave burst mode"));
237	return -1;
238}
239#endif /* ACPI_FUTURE_USAGE */
240
241static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, u8 command,
242					const u8 *wdata, unsigned wdata_len,
243					u8 *rdata, unsigned rdata_len)
244{
245	int result;
246
247	acpi_ec_write_cmd(ec, command);
248
249	for (; wdata_len > 0; wdata_len --) {
250		result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
251		if (result)
252			return result;
253		acpi_ec_write_data(ec, *(wdata++));
254	}
255
256	if (command == ACPI_EC_COMMAND_WRITE) {
257		result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
258		if (result)
259			return result;
260	}
261
262	for (; rdata_len > 0; rdata_len --) {
263		result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1);
264		if (result)
265			return result;
266
267		*(rdata++) = acpi_ec_read_data(ec);
268	}
269
270	return 0;
271}
272
273static int acpi_ec_transaction(struct acpi_ec *ec, u8 command,
274				const u8 *wdata, unsigned wdata_len,
275				u8 *rdata, unsigned rdata_len)
276{
277	int status;
278	u32 glk;
279
280	if (!ec || (wdata_len && !wdata) || (rdata_len && !rdata))
281		return -EINVAL;
282
283        if (rdata)
284                memset(rdata, 0, rdata_len);
285
286	if (ec->global_lock) {
287		status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
288		if (ACPI_FAILURE(status))
289			return -ENODEV;
290	}
291	down(&ec->sem);
292
293	status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
294	if (status) {
295		printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
296		goto end;
297	}
298
299        status = acpi_ec_transaction_unlocked(ec, command,
300                                              wdata, wdata_len,
301                                              rdata, rdata_len);
302
303end:
304	up(&ec->sem);
305
306	if (ec->global_lock)
307		acpi_release_global_lock(glk);
308
309	return status;
310}
311
312static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
313{
314	int result;
315	u8 d;
316
317	result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_READ,
318				     &address, 1, &d, 1);
319	*data = d;
320	return result;
321}
322
323static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
324{
325        u8 wdata[2] = { address, data };
326        return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE,
327				   wdata, 2, NULL, 0);
328}
329
330/*
331 * Externally callable EC access functions. For now, assume 1 EC only
332 */
333int ec_read(u8 addr, u8 *val)
334{
335	struct acpi_ec *ec;
336	int err;
337	u8 temp_data;
338
339	if (!first_ec)
340		return -ENODEV;
341
342	ec = acpi_driver_data(first_ec);
343
344	err = acpi_ec_read(ec, addr, &temp_data);
345
346	if (!err) {
347		*val = temp_data;
348		return 0;
349	} else
350		return err;
351}
352
353EXPORT_SYMBOL(ec_read);
354
355int ec_write(u8 addr, u8 val)
356{
357	struct acpi_ec *ec;
358	int err;
359
360	if (!first_ec)
361		return -ENODEV;
362
363	ec = acpi_driver_data(first_ec);
364
365	err = acpi_ec_write(ec, addr, val);
366
367	return err;
368}
369
370EXPORT_SYMBOL(ec_write);
371
372extern int ec_transaction(u8 command,
373                          const u8 *wdata, unsigned wdata_len,
374                          u8 *rdata, unsigned rdata_len)
375{
376	struct acpi_ec *ec;
377
378	if (!first_ec)
379		return -ENODEV;
380
381	ec = acpi_driver_data(first_ec);
382
383	return acpi_ec_transaction(ec, command, wdata,
384				   wdata_len, rdata, rdata_len);
385}
386
387EXPORT_SYMBOL(ec_transaction);
388
389static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
390{
391	int result;
392        u8 d;
393
394        if (!ec || !data)
395                return -EINVAL;
396
397        /*
398         * Query the EC to find out which _Qxx method we need to evaluate.
399         * Note that successful completion of the query causes the ACPI_EC_SCI
400         * bit to be cleared (and thus clearing the interrupt source).
401         */
402
403        result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1);
404        if (result)
405                return result;
406
407        if (!d)
408                return -ENODATA;
409
410        *data = d;
411        return 0;
412}
413
414/* --------------------------------------------------------------------------
415                                Event Management
416   -------------------------------------------------------------------------- */
417
418struct acpi_ec_query_data {
419	acpi_handle handle;
420	u8 data;
421};
422
423static void acpi_ec_gpe_query(void *ec_cxt)
424{
425	struct acpi_ec *ec = (struct acpi_ec *)ec_cxt;
426	u8 value = 0;
427	static char object_name[8];
428
429	if (!ec)
430		goto end;
431
432	value = acpi_ec_read_status(ec);
433
434	if (!(value & ACPI_EC_FLAG_SCI))
435		goto end;
436
437	if (acpi_ec_query(ec, &value))
438		goto end;
439
440	snprintf(object_name, 8, "_Q%2.2X", value);
441
442	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s", object_name));
443
444	acpi_evaluate_object(ec->handle, object_name, NULL, NULL);
445
446      end:
447	acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
448}
449
450static u32 acpi_ec_gpe_handler(void *data)
451{
452	acpi_status status = AE_OK;
453	u8 value;
454	struct acpi_ec *ec = (struct acpi_ec *)data;
455
456	acpi_clear_gpe(NULL, ec->gpe_bit, ACPI_ISR);
457	value = acpi_ec_read_status(ec);
458
459	if (acpi_ec_mode == EC_INTR) {
460		if (acpi_ec_check_status(value, ec->expect_event)) {
461			ec->expect_event = 0;
462			wake_up(&ec->wait);
463		}
464	}
465
466	if (value & ACPI_EC_FLAG_SCI) {
467		status = acpi_os_execute(OSL_EC_BURST_HANDLER, acpi_ec_gpe_query, ec);
468		return status == AE_OK ?
469		    ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
470	}
471	acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_ISR);
472	return status == AE_OK ?
473	    ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
474}
475
476/* --------------------------------------------------------------------------
477                             Address Space Management
478   -------------------------------------------------------------------------- */
479
480static acpi_status
481acpi_ec_space_setup(acpi_handle region_handle,
482		    u32 function, void *handler_context, void **return_context)
483{
484	/*
485	 * The EC object is in the handler context and is needed
486	 * when calling the acpi_ec_space_handler.
487	 */
488	*return_context = (function != ACPI_REGION_DEACTIVATE) ?
489	    handler_context : NULL;
490
491	return AE_OK;
492}
493
494static acpi_status
495acpi_ec_space_handler(u32 function,
496		      acpi_physical_address address,
497		      u32 bit_width,
498		      acpi_integer * value,
499		      void *handler_context, void *region_context)
500{
501	int result = 0;
502	struct acpi_ec *ec = NULL;
503	u64 temp = *value;
504	acpi_integer f_v = 0;
505	int i = 0;
506
507
508	if ((address > 0xFF) || !value || !handler_context)
509		return AE_BAD_PARAMETER;
510
511	if (bit_width != 8 && acpi_strict) {
512		return AE_BAD_PARAMETER;
513	}
514
515	ec = (struct acpi_ec *)handler_context;
516
517      next_byte:
518	switch (function) {
519	case ACPI_READ:
520		temp = 0;
521		result = acpi_ec_read(ec, (u8) address, (u8 *) &temp);
522		break;
523	case ACPI_WRITE:
524		result = acpi_ec_write(ec, (u8) address, (u8) temp);
525		break;
526	default:
527		result = -EINVAL;
528		goto out;
529		break;
530	}
531
532	bit_width -= 8;
533	if (bit_width) {
534		if (function == ACPI_READ)
535			f_v |= temp << 8 * i;
536		if (function == ACPI_WRITE)
537			temp >>= 8;
538		i++;
539		address++;
540		goto next_byte;
541	}
542
543	if (function == ACPI_READ) {
544		f_v |= temp << 8 * i;
545		*value = f_v;
546	}
547
548      out:
549	switch (result) {
550	case -EINVAL:
551		return AE_BAD_PARAMETER;
552		break;
553	case -ENODEV:
554		return AE_NOT_FOUND;
555		break;
556	case -ETIME:
557		return AE_TIME;
558		break;
559	default:
560		return AE_OK;
561	}
562}
563
564/* --------------------------------------------------------------------------
565                              FS Interface (/proc)
566   -------------------------------------------------------------------------- */
567
568static struct proc_dir_entry *acpi_ec_dir;
569
570static int acpi_ec_read_info(struct seq_file *seq, void *offset)
571{
572	struct acpi_ec *ec = (struct acpi_ec *)seq->private;
573
574
575	if (!ec)
576		goto end;
577
578	seq_printf(seq, "gpe bit:                 0x%02x\n",
579		   (u32) ec->gpe_bit);
580	seq_printf(seq, "ports:                   0x%02x, 0x%02x\n",
581		   (u32) ec->command_addr,
582		   (u32) ec->data_addr);
583	seq_printf(seq, "use global lock:         %s\n",
584		   ec->global_lock ? "yes" : "no");
585	acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
586
587      end:
588	return 0;
589}
590
591static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
592{
593	return single_open(file, acpi_ec_read_info, PDE(inode)->data);
594}
595
596static struct file_operations acpi_ec_info_ops = {
597	.open = acpi_ec_info_open_fs,
598	.read = seq_read,
599	.llseek = seq_lseek,
600	.release = single_release,
601	.owner = THIS_MODULE,
602};
603
604static int acpi_ec_add_fs(struct acpi_device *device)
605{
606	struct proc_dir_entry *entry = NULL;
607
608
609	if (!acpi_device_dir(device)) {
610		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
611						     acpi_ec_dir);
612		if (!acpi_device_dir(device))
613			return -ENODEV;
614	}
615
616	entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
617				  acpi_device_dir(device));
618	if (!entry)
619		return -ENODEV;
620	else {
621		entry->proc_fops = &acpi_ec_info_ops;
622		entry->data = acpi_driver_data(device);
623		entry->owner = THIS_MODULE;
624	}
625
626	return 0;
627}
628
629static int acpi_ec_remove_fs(struct acpi_device *device)
630{
631
632	if (acpi_device_dir(device)) {
633		remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
634		remove_proc_entry(acpi_device_bid(device), acpi_ec_dir);
635		acpi_device_dir(device) = NULL;
636	}
637
638	return 0;
639}
640
641/* --------------------------------------------------------------------------
642                               Driver Interface
643   -------------------------------------------------------------------------- */
644
645static int acpi_ec_add(struct acpi_device *device)
646{
647	int result = 0;
648	acpi_status status = AE_OK;
649	struct acpi_ec *ec = NULL;
650
651
652	if (!device)
653		return -EINVAL;
654
655	ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
656	if (!ec)
657		return -ENOMEM;
658	memset(ec, 0, sizeof(struct acpi_ec));
659
660	ec->handle = device->handle;
661	ec->uid = -1;
662	init_MUTEX(&ec->sem);
663	if (acpi_ec_mode == EC_INTR) {
664		atomic_set(&ec->leaving_burst, 1);
665		init_waitqueue_head(&ec->wait);
666	}
667	strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
668	strcpy(acpi_device_class(device), ACPI_EC_CLASS);
669	acpi_driver_data(device) = ec;
670
671	/* Use the global lock for all EC transactions? */
672	acpi_evaluate_integer(ec->handle, "_GLK", NULL,
673			      &ec->global_lock);
674
675	/* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
676	   http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
677	if (ec_ecdt) {
678		acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
679						  ACPI_ADR_SPACE_EC,
680						  &acpi_ec_space_handler);
681
682		acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
683					&acpi_ec_gpe_handler);
684
685		kfree(ec_ecdt);
686	}
687
688	/* Get GPE bit assignment (EC events). */
689	/* TODO: Add support for _GPE returning a package */
690	status =
691	    acpi_evaluate_integer(ec->handle, "_GPE", NULL,
692				  &ec->gpe_bit);
693	if (ACPI_FAILURE(status)) {
694		ACPI_EXCEPTION((AE_INFO, status, "Obtaining GPE bit assignment"));
695		result = -ENODEV;
696		goto end;
697	}
698
699	result = acpi_ec_add_fs(device);
700	if (result)
701		goto end;
702
703	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s [%s] (gpe %d) interrupt mode.",
704	       acpi_device_name(device), acpi_device_bid(device),
705	       (u32) ec->gpe_bit));
706
707	if (!first_ec)
708		first_ec = device;
709
710  end:
711	if (result)
712		kfree(ec);
713
714	return result;
715}
716
717static int acpi_ec_remove(struct acpi_device *device, int type)
718{
719	struct acpi_ec *ec = NULL;
720
721
722	if (!device)
723		return -EINVAL;
724
725	ec = acpi_driver_data(device);
726
727	acpi_ec_remove_fs(device);
728
729	kfree(ec);
730
731	return 0;
732}
733
734static acpi_status
735acpi_ec_io_ports(struct acpi_resource *resource, void *context)
736{
737	struct acpi_ec *ec = (struct acpi_ec *)context;
738
739	if (resource->type != ACPI_RESOURCE_TYPE_IO) {
740		return AE_OK;
741	}
742
743	/*
744	 * The first address region returned is the data port, and
745	 * the second address region returned is the status/command
746	 * port.
747	 */
748	if (ec->data_addr == 0) {
749		ec->data_addr = resource->data.io.minimum;
750	} else if (ec->command_addr == 0) {
751		ec->command_addr = resource->data.io.minimum;
752	} else {
753		return AE_CTRL_TERMINATE;
754	}
755
756	return AE_OK;
757}
758
759static int acpi_ec_start(struct acpi_device *device)
760{
761	acpi_status status = AE_OK;
762	struct acpi_ec *ec = NULL;
763
764
765	if (!device)
766		return -EINVAL;
767
768	ec = acpi_driver_data(device);
769
770	if (!ec)
771		return -EINVAL;
772
773	/*
774	 * Get I/O port addresses. Convert to GAS format.
775	 */
776	status = acpi_walk_resources(ec->handle, METHOD_NAME__CRS,
777				     acpi_ec_io_ports, ec);
778	if (ACPI_FAILURE(status) || ec->command_addr == 0) {
779		ACPI_EXCEPTION((AE_INFO, status,
780				"Error getting I/O port addresses"));
781		return -ENODEV;
782	}
783
784	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02lx, ports=0x%2lx,0x%2lx",
785			  ec->gpe_bit, ec->command_addr, ec->data_addr));
786
787	/*
788	 * Install GPE handler
789	 */
790	status = acpi_install_gpe_handler(NULL, ec->gpe_bit,
791					  ACPI_GPE_EDGE_TRIGGERED,
792					  &acpi_ec_gpe_handler, ec);
793	if (ACPI_FAILURE(status)) {
794		return -ENODEV;
795	}
796	acpi_set_gpe_type(NULL, ec->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
797	acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
798
799	status = acpi_install_address_space_handler(ec->handle,
800						    ACPI_ADR_SPACE_EC,
801						    &acpi_ec_space_handler,
802						    &acpi_ec_space_setup, ec);
803	if (ACPI_FAILURE(status)) {
804		acpi_remove_gpe_handler(NULL, ec->gpe_bit,
805					&acpi_ec_gpe_handler);
806		return -ENODEV;
807	}
808
809	return AE_OK;
810}
811
812static int acpi_ec_stop(struct acpi_device *device, int type)
813{
814	acpi_status status = AE_OK;
815	struct acpi_ec *ec = NULL;
816
817
818	if (!device)
819		return -EINVAL;
820
821	ec = acpi_driver_data(device);
822
823	status = acpi_remove_address_space_handler(ec->handle,
824						   ACPI_ADR_SPACE_EC,
825						   &acpi_ec_space_handler);
826	if (ACPI_FAILURE(status))
827		return -ENODEV;
828
829	status =
830	    acpi_remove_gpe_handler(NULL, ec->gpe_bit,
831				    &acpi_ec_gpe_handler);
832	if (ACPI_FAILURE(status))
833		return -ENODEV;
834
835	return 0;
836}
837
838static acpi_status __init
839acpi_fake_ecdt_callback(acpi_handle handle,
840			u32 Level, void *context, void **retval)
841{
842	acpi_status status;
843
844	init_MUTEX(&ec_ecdt->sem);
845	if (acpi_ec_mode == EC_INTR) {
846		init_waitqueue_head(&ec_ecdt->wait);
847	}
848	status = acpi_walk_resources(handle, METHOD_NAME__CRS,
849				     acpi_ec_io_ports, ec_ecdt);
850	if (ACPI_FAILURE(status))
851		return status;
852
853	ec_ecdt->uid = -1;
854	acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->uid);
855
856	status =
857	    acpi_evaluate_integer(handle, "_GPE", NULL,
858				  &ec_ecdt->gpe_bit);
859	if (ACPI_FAILURE(status))
860		return status;
861	ec_ecdt->global_lock = TRUE;
862	ec_ecdt->handle = handle;
863
864	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "GPE=0x%02lx, ports=0x%2lx, 0x%2lx",
865	       ec_ecdt->gpe_bit, ec_ecdt->command_addr, ec_ecdt->data_addr));
866
867	return AE_CTRL_TERMINATE;
868}
869
870/*
871 * Some BIOS (such as some from Gateway laptops) access EC region very early
872 * such as in BAT0._INI or EC._INI before an EC device is found and
873 * do not provide an ECDT. According to ACPI spec, ECDT isn't mandatorily
874 * required, but if EC regison is accessed early, it is required.
875 * The routine tries to workaround the BIOS bug by pre-scan EC device
876 * It assumes that _CRS, _HID, _GPE, _UID methods of EC don't touch any
877 * op region (since _REG isn't invoked yet). The assumption is true for
878 * all systems found.
879 */
880static int __init acpi_ec_fake_ecdt(void)
881{
882	acpi_status status;
883	int ret = 0;
884
885	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Try to make an fake ECDT"));
886
887	ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
888	if (!ec_ecdt) {
889		ret = -ENOMEM;
890		goto error;
891	}
892	memset(ec_ecdt, 0, sizeof(struct acpi_ec));
893
894	status = acpi_get_devices(ACPI_EC_HID,
895				  acpi_fake_ecdt_callback, NULL, NULL);
896	if (ACPI_FAILURE(status)) {
897		kfree(ec_ecdt);
898		ec_ecdt = NULL;
899		ret = -ENODEV;
900		ACPI_EXCEPTION((AE_INFO, status, "Can't make an fake ECDT"));
901		goto error;
902	}
903	return 0;
904  error:
905	return ret;
906}
907
908static int __init acpi_ec_get_real_ecdt(void)
909{
910	acpi_status status;
911	struct acpi_table_ecdt *ecdt_ptr;
912
913	status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
914					 (struct acpi_table_header **)
915					 &ecdt_ptr);
916	if (ACPI_FAILURE(status))
917		return -ENODEV;
918
919	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found ECDT"));
920
921	/*
922	 * Generate a temporary ec context to use until the namespace is scanned
923	 */
924	ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
925	if (!ec_ecdt)
926		return -ENOMEM;
927	memset(ec_ecdt, 0, sizeof(struct acpi_ec));
928
929	init_MUTEX(&ec_ecdt->sem);
930	if (acpi_ec_mode == EC_INTR) {
931		init_waitqueue_head(&ec_ecdt->wait);
932	}
933	ec_ecdt->command_addr = ecdt_ptr->ec_control.address;
934	ec_ecdt->data_addr = ecdt_ptr->ec_data.address;
935	ec_ecdt->gpe_bit = ecdt_ptr->gpe_bit;
936	/* use the GL just to be safe */
937	ec_ecdt->global_lock = TRUE;
938	ec_ecdt->uid = ecdt_ptr->uid;
939
940	status =
941	    acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->handle);
942	if (ACPI_FAILURE(status)) {
943		goto error;
944	}
945
946	return 0;
947  error:
948	ACPI_EXCEPTION((AE_INFO, status, "Could not use ECDT"));
949	kfree(ec_ecdt);
950	ec_ecdt = NULL;
951
952	return -ENODEV;
953}
954
955static int __initdata acpi_fake_ecdt_enabled;
956int __init acpi_ec_ecdt_probe(void)
957{
958	acpi_status status;
959	int ret;
960
961	ret = acpi_ec_get_real_ecdt();
962	/* Try to make a fake ECDT */
963	if (ret && acpi_fake_ecdt_enabled) {
964		ret = acpi_ec_fake_ecdt();
965	}
966
967	if (ret)
968		return 0;
969
970	/*
971	 * Install GPE handler
972	 */
973	status = acpi_install_gpe_handler(NULL, ec_ecdt->gpe_bit,
974					  ACPI_GPE_EDGE_TRIGGERED,
975					  &acpi_ec_gpe_handler, ec_ecdt);
976	if (ACPI_FAILURE(status)) {
977		goto error;
978	}
979	acpi_set_gpe_type(NULL, ec_ecdt->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
980	acpi_enable_gpe(NULL, ec_ecdt->gpe_bit, ACPI_NOT_ISR);
981
982	status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
983						    ACPI_ADR_SPACE_EC,
984						    &acpi_ec_space_handler,
985						    &acpi_ec_space_setup,
986						    ec_ecdt);
987	if (ACPI_FAILURE(status)) {
988		acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
989					&acpi_ec_gpe_handler);
990		goto error;
991	}
992
993	return 0;
994
995      error:
996	ACPI_EXCEPTION((AE_INFO, status, "Could not use ECDT"));
997	kfree(ec_ecdt);
998	ec_ecdt = NULL;
999
1000	return -ENODEV;
1001}
1002
1003static int __init acpi_ec_init(void)
1004{
1005	int result = 0;
1006
1007
1008	if (acpi_disabled)
1009		return 0;
1010
1011	acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
1012	if (!acpi_ec_dir)
1013		return -ENODEV;
1014
1015	/* Now register the driver for the EC */
1016	result = acpi_bus_register_driver(&acpi_ec_driver);
1017	if (result < 0) {
1018		remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1019		return -ENODEV;
1020	}
1021
1022	return result;
1023}
1024
1025subsys_initcall(acpi_ec_init);
1026
1027/* EC driver currently not unloadable */
1028#if 0
1029static void __exit acpi_ec_exit(void)
1030{
1031
1032	acpi_bus_unregister_driver(&acpi_ec_driver);
1033
1034	remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1035
1036	return;
1037}
1038#endif				/* 0 */
1039
1040static int __init acpi_fake_ecdt_setup(char *str)
1041{
1042	acpi_fake_ecdt_enabled = 1;
1043	return 1;
1044}
1045
1046__setup("acpi_fake_ecdt", acpi_fake_ecdt_setup);
1047static int __init acpi_ec_set_intr_mode(char *str)
1048{
1049	int intr;
1050
1051	if (!get_option(&str, &intr))
1052		return 0;
1053
1054	if (intr) {
1055		acpi_ec_mode = EC_INTR;
1056	} else {
1057		acpi_ec_mode = EC_POLL;
1058	}
1059	acpi_ec_driver.ops.add = acpi_ec_add;
1060	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "EC %s mode.\n", intr ? "interrupt" : "polling"));
1061
1062	return 1;
1063}
1064
1065__setup("ec_intr=", acpi_ec_set_intr_mode);
1066