core.c 7.78 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5
/*
 * pnpacpi -- PnP ACPI driver
 *
 * Copyright (c) 2004 Matthieu Castet <castet.matthieu@free.fr>
 * Copyright (c) 2004 Li Shaohua <shaohua.li@intel.com>
6
 *
Linus Torvalds's avatar
Linus Torvalds committed
7 8 9 10 11 12 13 14 15 16 17 18 19 20
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
21

Linus Torvalds's avatar
Linus Torvalds committed
22 23
#include <linux/acpi.h>
#include <linux/pnp.h>
24
#include <linux/mod_devicetable.h>
Linus Torvalds's avatar
Linus Torvalds committed
25
#include <acpi/acpi_bus.h>
26 27
#include <acpi/actypes.h>

28
#include "../base.h"
Linus Torvalds's avatar
Linus Torvalds committed
29 30 31 32
#include "pnpacpi.h"

static int num = 0;

33 34 35 36 37
/* We need only to blacklist devices that have already an acpi driver that
 * can't use pnp layer. We don't need to blacklist device that are directly
 * used by the kernel (PCI root, ...), as it is harmless and there were
 * already present in pnpbios. But there is an exception for devices that
 * have irqs (PIC, Timer) because we call acpi_register_gsi.
Bjorn Helgaas's avatar
Bjorn Helgaas committed
38
 * Finally, only devices that have a CRS method need to be in this list.
39
 */
40
static struct acpi_device_id excluded_id_list[] __initdata = {
41 42 43 44
	{"PNP0C09", 0},		/* EC */
	{"PNP0C0F", 0},		/* Link device */
	{"PNP0000", 0},		/* PIC */
	{"PNP0100", 0},		/* Timer */
45 46 47
	{"", 0},
};

Linus Torvalds's avatar
Linus Torvalds committed
48 49
static inline int is_exclusive_device(struct acpi_device *dev)
{
50
	return (!acpi_match_device_ids(dev, excluded_id_list));
Linus Torvalds's avatar
Linus Torvalds committed
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
}

/*
 * Compatible Device IDs
 */
#define TEST_HEX(c) \
	if (!(('0' <= (c) && (c) <= '9') || ('A' <= (c) && (c) <= 'F'))) \
		return 0
#define TEST_ALPHA(c) \
	if (!('@' <= (c) || (c) <= 'Z')) \
		return 0
static int __init ispnpidacpi(char *id)
{
	TEST_ALPHA(id[0]);
	TEST_ALPHA(id[1]);
	TEST_ALPHA(id[2]);
	TEST_HEX(id[3]);
	TEST_HEX(id[4]);
	TEST_HEX(id[5]);
	TEST_HEX(id[6]);
	if (id[7] != '\0')
		return 0;
	return 1;
}

76
static int pnpacpi_get_resources(struct pnp_dev *dev)
Linus Torvalds's avatar
Linus Torvalds committed
77 78
{
	acpi_status status;
Bjorn Helgaas's avatar
Bjorn Helgaas committed
79

80
	dev_dbg(&dev->dev, "get resources\n");
81
	status = pnpacpi_parse_allocated_resource(dev);
Linus Torvalds's avatar
Linus Torvalds committed
82 83 84
	return ACPI_FAILURE(status) ? -ENODEV : 0;
}

85
static int pnpacpi_set_resources(struct pnp_dev *dev)
Linus Torvalds's avatar
Linus Torvalds committed
86 87 88
{
	acpi_handle handle = dev->data;
	struct acpi_buffer buffer;
89
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
90 91
	acpi_status status;

92
	dev_dbg(&dev->dev, "set resources\n");
93
	ret = pnpacpi_build_resource_template(dev, &buffer);
Linus Torvalds's avatar
Linus Torvalds committed
94 95
	if (ret)
		return ret;
96
	ret = pnpacpi_encode_resources(dev, &buffer);
Linus Torvalds's avatar
Linus Torvalds committed
97 98 99 100 101 102 103 104 105 106 107 108 109 110
	if (ret) {
		kfree(buffer.pointer);
		return ret;
	}
	status = acpi_set_current_resources(handle, &buffer);
	if (ACPI_FAILURE(status))
		ret = -EINVAL;
	kfree(buffer.pointer);
	return ret;
}

static int pnpacpi_disable_resources(struct pnp_dev *dev)
{
	acpi_status status;
111

Linus Torvalds's avatar
Linus Torvalds committed
112
	/* acpi_unregister_gsi(pnp_irq(dev, 0)); */
113 114
	status = acpi_evaluate_object((acpi_handle) dev->data,
				      "_DIS", NULL, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
115 116 117
	return ACPI_FAILURE(status) ? -ENODEV : 0;
}

Len Brown's avatar
Len Brown committed
118
#ifdef CONFIG_ACPI_SLEEP
119 120
static int pnpacpi_suspend(struct pnp_dev *dev, pm_message_t state)
{
121 122 123 124 125 126 127 128 129 130
	int power_state;

	power_state = acpi_pm_device_sleep_state(&dev->dev,
						device_may_wakeup(&dev->dev),
						NULL);
	if (power_state < 0)
		power_state = (state.event == PM_EVENT_ON) ?
				ACPI_STATE_D0 : ACPI_STATE_D3;

	return acpi_bus_set_power((acpi_handle) dev->data, power_state);
131 132 133 134
}

static int pnpacpi_resume(struct pnp_dev *dev)
{
135
	return acpi_bus_set_power((acpi_handle) dev->data, ACPI_STATE_D0);
136
}
Len Brown's avatar
Len Brown committed
137
#endif
138

Adrian Bunk's avatar
Adrian Bunk committed
139
static struct pnp_protocol pnpacpi_protocol = {
Bjorn Helgaas's avatar
Bjorn Helgaas committed
140 141 142
	.name	 = "Plug and Play ACPI",
	.get	 = pnpacpi_get_resources,
	.set	 = pnpacpi_set_resources,
Linus Torvalds's avatar
Linus Torvalds committed
143
	.disable = pnpacpi_disable_resources,
Len Brown's avatar
Len Brown committed
144
#ifdef CONFIG_ACPI_SLEEP
145 146
	.suspend = pnpacpi_suspend,
	.resume = pnpacpi_resume,
Len Brown's avatar
Len Brown committed
147
#endif
Linus Torvalds's avatar
Linus Torvalds committed
148 149 150 151 152 153 154 155
};

static int __init pnpacpi_add_device(struct acpi_device *device)
{
	acpi_handle temp = NULL;
	acpi_status status;
	struct pnp_dev *dev;

156 157
	status = acpi_get_handle(device->handle, "_CRS", &temp);
	if (ACPI_FAILURE(status) || !ispnpidacpi(acpi_device_hid(device)) ||
158
	    is_exclusive_device(device))
Linus Torvalds's avatar
Linus Torvalds committed
159 160
		return 0;

Bjorn Helgaas's avatar
Bjorn Helgaas committed
161 162
	dev = pnp_alloc_dev(&pnpacpi_protocol, num, acpi_device_hid(device));
	if (!dev)
Linus Torvalds's avatar
Linus Torvalds committed
163
		return -ENOMEM;
Bjorn Helgaas's avatar
Bjorn Helgaas committed
164

Linus Torvalds's avatar
Linus Torvalds committed
165
	dev->data = device->handle;
Bjorn Helgaas's avatar
Bjorn Helgaas committed
166
	/* .enabled means the device can decode the resources */
Linus Torvalds's avatar
Linus Torvalds committed
167 168 169 170 171
	dev->active = device->status.enabled;
	status = acpi_get_handle(device->handle, "_SRS", &temp);
	if (ACPI_SUCCESS(status))
		dev->capabilities |= PNP_CONFIGURABLE;
	dev->capabilities |= PNP_READ;
172
	if (device->flags.dynamic_status && (dev->capabilities & PNP_CONFIGURABLE))
Linus Torvalds's avatar
Linus Torvalds committed
173 174 175 176 177 178 179 180 181 182 183 184
		dev->capabilities |= PNP_WRITE;
	if (device->flags.removable)
		dev->capabilities |= PNP_REMOVABLE;
	status = acpi_get_handle(device->handle, "_DIS", &temp);
	if (ACPI_SUCCESS(status))
		dev->capabilities |= PNP_DISABLE;

	if (strlen(acpi_device_name(device)))
		strncpy(dev->name, acpi_device_name(device), sizeof(dev->name));
	else
		strncpy(dev->name, acpi_device_bid(device), sizeof(dev->name));

185
	if (dev->active) {
Linus Torvalds's avatar
Linus Torvalds committed
186
		/* parse allocated resource */
187
		status = pnpacpi_parse_allocated_resource(dev);
Linus Torvalds's avatar
Linus Torvalds committed
188
		if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
189
			pnp_err("PnPACPI: METHOD_NAME__CRS failure for %s",
190
				acpi_device_hid(device));
Linus Torvalds's avatar
Linus Torvalds committed
191 192 193
		}
	}

194
	if (dev->capabilities & PNP_CONFIGURABLE) {
195
		status = pnpacpi_parse_resource_option_data(dev);
Linus Torvalds's avatar
Linus Torvalds committed
196
		if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
197
			pnp_err("PnPACPI: METHOD_NAME__PRS failure for %s",
198
				acpi_device_hid(device));
Linus Torvalds's avatar
Linus Torvalds committed
199 200
		}
	}
201

Linus Torvalds's avatar
Linus Torvalds committed
202 203 204 205 206 207 208
	if (device->flags.compatible_ids) {
		struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
		int i;

		for (i = 0; i < cid_list->count; i++) {
			if (!ispnpidacpi(cid_list->id[i].value))
				continue;
209
			pnp_add_id(dev, cid_list->id[i].value);
Linus Torvalds's avatar
Linus Torvalds committed
210 211 212 213 214
		}
	}

	/* clear out the damaged flags */
	if (!dev->active)
215
		pnp_init_resources(dev);
Linus Torvalds's avatar
Linus Torvalds committed
216
	pnp_add_device(dev);
217
	num++;
Linus Torvalds's avatar
Linus Torvalds committed
218 219 220 221 222

	return AE_OK;
}

static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle,
223 224
						     u32 lvl, void *context,
						     void **rv)
Linus Torvalds's avatar
Linus Torvalds committed
225 226 227 228 229 230 231 232 233 234
{
	struct acpi_device *device;

	if (!acpi_bus_get_device(handle, &device))
		pnpacpi_add_device(device);
	else
		return AE_CTRL_DEPTH;
	return AE_OK;
}

235 236
static int __init acpi_pnp_match(struct device *dev, void *_pnp)
{
237 238
	struct acpi_device *acpi = to_acpi_device(dev);
	struct pnp_dev *pnp = _pnp;
239 240 241

	/* true means it matched */
	return acpi->flags.hardware_id
242 243
	    && !acpi_get_physical_device(acpi->handle)
	    && compare_pnp_id(pnp->id, acpi->pnp.hardware_id);
244 245
}

246
static int __init acpi_pnp_find_device(struct device *dev, acpi_handle * handle)
247
{
248 249
	struct device *adev;
	struct acpi_device *acpi;
250 251

	adev = bus_find_device(&acpi_bus_type, NULL,
252
			       to_pnp_dev(dev), acpi_pnp_match);
253 254 255 256 257 258 259 260 261 262 263 264 265
	if (!adev)
		return -ENODEV;

	acpi = to_acpi_device(adev);
	*handle = acpi->handle;
	put_device(adev);
	return 0;
}

/* complete initialization of a PNPACPI device includes having
 * pnpdev->dev.archdata.acpi_handle point to its ACPI sibling.
 */
static struct acpi_bus_type __initdata acpi_pnp_bus = {
Bjorn Helgaas's avatar
Bjorn Helgaas committed
266
	.bus	     = &pnp_bus_type,
267 268 269
	.find_device = acpi_pnp_find_device,
};

Linus Torvalds's avatar
Linus Torvalds committed
270
int pnpacpi_disabled __initdata;
Adrian Bunk's avatar
Adrian Bunk committed
271
static int __init pnpacpi_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
272 273 274 275 276 277 278
{
	if (acpi_disabled || pnpacpi_disabled) {
		pnp_info("PnP ACPI: disabled");
		return 0;
	}
	pnp_info("PnP ACPI init");
	pnp_register_protocol(&pnpacpi_protocol);
279
	register_acpi_bus_type(&acpi_pnp_bus);
Linus Torvalds's avatar
Linus Torvalds committed
280 281
	acpi_get_devices(NULL, pnpacpi_add_device_handler, NULL, NULL);
	pnp_info("PnP ACPI: found %d devices", num);
282
	unregister_acpi_bus_type(&acpi_pnp_bus);
283
	pnp_platform_devices = 1;
Linus Torvalds's avatar
Linus Torvalds committed
284 285
	return 0;
}
286

Linus Torvalds's avatar
Linus Torvalds committed
287 288 289 290 291 292 293 294 295 296
subsys_initcall(pnpacpi_init);

static int __init pnpacpi_setup(char *str)
{
	if (str == NULL)
		return 1;
	if (!strncmp(str, "off", 3))
		pnpacpi_disabled = 1;
	return 1;
}
297

Linus Torvalds's avatar
Linus Torvalds committed
298
__setup("pnpacpi=", pnpacpi_setup);