[net-next-2.6.git] / drivers / acpi / atomicio.c

/*
 * atomicio.c - ACPI IO memory pre-mapping/post-unmapping, then
 * accessing in atomic context.
 *
 * This is used for NMI handler to access IO memory area, because
 * ioremap/iounmap can not be used in NMI handler. The IO memory area
 * is pre-mapped in process context and accessed in NMI handler.
 *
 * Copyright (C) 2009-2010, Intel Corp.
 *	Author: Huang Ying <ying.huang@intel.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 as published by the Free Software Foundation.
 *
 * 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
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/acpi.h>
#include <linux/io.h>
#include <linux/kref.h>
#include <linux/rculist.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <acpi/atomicio.h>

#define ACPI_PFX "ACPI: "

static LIST_HEAD(acpi_iomaps);
/*
 * Used for mutual exclusion between writers of acpi_iomaps list, for
 * synchronization between readers and writer, RCU is used.
 */
static DEFINE_SPINLOCK(acpi_iomaps_lock);

struct acpi_iomap {
	struct list_head list;
	void __iomem *vaddr;
	unsigned long size;
	phys_addr_t paddr;
	struct kref ref;
};

/* acpi_iomaps_lock or RCU read lock must be held before calling */
static struct acpi_iomap *__acpi_find_iomap(phys_addr_t paddr,
					    unsigned long size)
{
	struct acpi_iomap *map;

	list_for_each_entry_rcu(map, &acpi_iomaps, list) {
		if (map->paddr + map->size >= paddr + size &&
		    map->paddr <= paddr)
			return map;
	}
	return NULL;
}

/*
 * Atomic "ioremap" used by NMI handler, if the specified IO memory
 * area is not pre-mapped, NULL will be returned.
 *
 * acpi_iomaps_lock or RCU read lock must be held before calling
 */
static void __iomem *__acpi_ioremap_fast(phys_addr_t paddr,
					 unsigned long size)
{
	struct acpi_iomap *map;

	map = __acpi_find_iomap(paddr, size);
	if (map)
		return map->vaddr + (paddr - map->paddr);
	else
		return NULL;
}

/* acpi_iomaps_lock must be held before calling */
static void __iomem *__acpi_try_ioremap(phys_addr_t paddr,
					unsigned long size)
{
	struct acpi_iomap *map;

	map = __acpi_find_iomap(paddr, size);
	if (map) {
		kref_get(&map->ref);
		return map->vaddr + (paddr - map->paddr);
	} else
		return NULL;
}

/*
 * Used to pre-map the specified IO memory area. First try to find
 * whether the area is already pre-mapped, if it is, increase the
 * reference count (in __acpi_try_ioremap) and return; otherwise, do
 * the real ioremap, and add the mapping into acpi_iomaps list.
 */
static void __iomem *acpi_pre_map(phys_addr_t paddr,
				  unsigned long size)
{
	void __iomem *vaddr;
	struct acpi_iomap *map;
	unsigned long pg_sz, flags;
	phys_addr_t pg_off;

	spin_lock_irqsave(&acpi_iomaps_lock, flags);
	vaddr = __acpi_try_ioremap(paddr, size);
	spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
	if (vaddr)
		return vaddr;

	pg_off = paddr & PAGE_MASK;
	pg_sz = ((paddr + size + PAGE_SIZE - 1) & PAGE_MASK) - pg_off;
	vaddr = ioremap(pg_off, pg_sz);
	if (!vaddr)
		return NULL;
	map = kmalloc(sizeof(*map), GFP_KERNEL);
	if (!map)
		goto err_unmap;
	INIT_LIST_HEAD(&map->list);
	map->paddr = pg_off;
	map->size = pg_sz;
	map->vaddr = vaddr;
	kref_init(&map->ref);

	spin_lock_irqsave(&acpi_iomaps_lock, flags);
	vaddr = __acpi_try_ioremap(paddr, size);
	if (vaddr) {
		spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
		iounmap(map->vaddr);
		kfree(map);
		return vaddr;
	}
	list_add_tail_rcu(&map->list, &acpi_iomaps);
	spin_unlock_irqrestore(&acpi_iomaps_lock, flags);

	return vaddr + (paddr - pg_off);
err_unmap:
	iounmap(vaddr);
	return NULL;
}

/* acpi_iomaps_lock must be held before calling */
static void __acpi_kref_del_iomap(struct kref *ref)
{
	struct acpi_iomap *map;

	map = container_of(ref, struct acpi_iomap, ref);
	list_del_rcu(&map->list);
}

/*
 * Used to post-unmap the specified IO memory area. The iounmap is
 * done only if the reference count goes zero.
 */
static void acpi_post_unmap(phys_addr_t paddr, unsigned long size)
{
	struct acpi_iomap *map;
	unsigned long flags;
	int del;

	spin_lock_irqsave(&acpi_iomaps_lock, flags);
	map = __acpi_find_iomap(paddr, size);
	BUG_ON(!map);
	del = kref_put(&map->ref, __acpi_kref_del_iomap);
	spin_unlock_irqrestore(&acpi_iomaps_lock, flags);

	if (!del)
		return;

	synchronize_rcu();
	iounmap(map->vaddr);
	kfree(map);
}

/* In NMI handler, should set silent = 1 */
static int acpi_check_gar(struct acpi_generic_address *reg,
			  u64 *paddr, int silent)
{
	u32 width, space_id;

	width = reg->bit_width;
	space_id = reg->space_id;
	/* Handle possible alignment issues */
	memcpy(paddr, &reg->address, sizeof(*paddr));
	if (!*paddr) {
		if (!silent)
			pr_warning(FW_BUG ACPI_PFX
			"Invalid physical address in GAR [0x%llx/%u/%u]\n",
				   *paddr, width, space_id);
		return -EINVAL;
	}

	if ((width != 8) && (width != 16) && (width != 32) && (width != 64)) {
		if (!silent)
			pr_warning(FW_BUG ACPI_PFX
				   "Invalid bit width in GAR [0x%llx/%u/%u]\n",
				   *paddr, width, space_id);
		return -EINVAL;
	}

	if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY &&
	    space_id != ACPI_ADR_SPACE_SYSTEM_IO) {
		if (!silent)
			pr_warning(FW_BUG ACPI_PFX
			"Invalid address space type in GAR [0x%llx/%u/%u]\n",
				   *paddr, width, space_id);
		return -EINVAL;
	}

	return 0;
}

/* Pre-map, working on GAR */
int acpi_pre_map_gar(struct acpi_generic_address *reg)
{
	u64 paddr;
	void __iomem *vaddr;
	int rc;

	if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
		return 0;

	rc = acpi_check_gar(reg, &paddr, 0);
	if (rc)
		return rc;

	vaddr = acpi_pre_map(paddr, reg->bit_width / 8);
	if (!vaddr)
		return -EIO;

	return 0;
}
EXPORT_SYMBOL_GPL(acpi_pre_map_gar);

/* Post-unmap, working on GAR */
int acpi_post_unmap_gar(struct acpi_generic_address *reg)
{
	u64 paddr;
	int rc;

	if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
		return 0;

	rc = acpi_check_gar(reg, &paddr, 0);
	if (rc)
		return rc;

	acpi_post_unmap(paddr, reg->bit_width / 8);

	return 0;
}
EXPORT_SYMBOL_GPL(acpi_post_unmap_gar);

/*
 * Can be used in atomic (including NMI) or process context. RCU read
 * lock can only be released after the IO memory area accessing.
 */
static int acpi_atomic_read_mem(u64 paddr, u64 *val, u32 width)
{
	void __iomem *addr;

	rcu_read_lock();
	addr = __acpi_ioremap_fast(paddr, width);
	switch (width) {
	case 8:
		*val = readb(addr);
		break;
	case 16:
		*val = readw(addr);
		break;
	case 32:
		*val = readl(addr);
		break;
	case 64:
		*val = readq(addr);
		break;
	default:
		return -EINVAL;
	}
	rcu_read_unlock();

	return 0;
}

static int acpi_atomic_write_mem(u64 paddr, u64 val, u32 width)
{
	void __iomem *addr;

	rcu_read_lock();
	addr = __acpi_ioremap_fast(paddr, width);
	switch (width) {
	case 8:
		writeb(val, addr);
		break;
	case 16:
		writew(val, addr);
		break;
	case 32:
		writel(val, addr);
		break;
	case 64:
		writeq(val, addr);
		break;
	default:
		return -EINVAL;
	}
	rcu_read_unlock();

	return 0;
}

/* GAR accessing in atomic (including NMI) or process context */
int acpi_atomic_read(u64 *val, struct acpi_generic_address *reg)
{
	u64 paddr;
	int rc;

	rc = acpi_check_gar(reg, &paddr, 1);
	if (rc)
		return rc;

	*val = 0;
	switch (reg->space_id) {
	case ACPI_ADR_SPACE_SYSTEM_MEMORY:
		return acpi_atomic_read_mem(paddr, val, reg->bit_width);
	case ACPI_ADR_SPACE_SYSTEM_IO:
		return acpi_os_read_port(paddr, (u32 *)val, reg->bit_width);
	default:
		return -EINVAL;
	}
}
EXPORT_SYMBOL_GPL(acpi_atomic_read);

int acpi_atomic_write(u64 val, struct acpi_generic_address *reg)
{
	u64 paddr;
	int rc;

	rc = acpi_check_gar(reg, &paddr, 1);
	if (rc)
		return rc;

	switch (reg->space_id) {
	case ACPI_ADR_SPACE_SYSTEM_MEMORY:
		return acpi_atomic_write_mem(paddr, val, reg->bit_width);
	case ACPI_ADR_SPACE_SYSTEM_IO:
		return acpi_os_write_port(paddr, val, reg->bit_width);
	default:
		return -EINVAL;
	}
}
EXPORT_SYMBOL_GPL(acpi_atomic_write);
Commit	Line	Data
15651291 HY	1	/*
	2	* atomicio.c - ACPI IO memory pre-mapping/post-unmapping, then
	3	* accessing in atomic context.
	4	*
	5	* This is used for NMI handler to access IO memory area, because
	6	* ioremap/iounmap can not be used in NMI handler. The IO memory area
	7	* is pre-mapped in process context and accessed in NMI handler.
	8	*
	9	* Copyright (C) 2009-2010, Intel Corp.
	10	* Author: Huang Ying <ying.huang@intel.com>
	11	*
	12	* This program is free software; you can redistribute it and/or
	13	* modify it under the terms of the GNU General Public License version
	14	* 2 as published by the Free Software Foundation.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with this program; if not, write to the Free Software
	23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	24	*/
	25
	26	#include <linux/kernel.h>
	27	#include <linux/module.h>
	28	#include <linux/init.h>
	29	#include <linux/acpi.h>
	30	#include <linux/io.h>
	31	#include <linux/kref.h>
	32	#include <linux/rculist.h>
	33	#include <linux/interrupt.h>
e0fb8c41	34	#include <linux/slab.h>
15651291 HY	35	#include <acpi/atomicio.h>
	36
	37	#define ACPI_PFX "ACPI: "
	38
	39	static LIST_HEAD(acpi_iomaps);
	40	/*
	41	* Used for mutual exclusion between writers of acpi_iomaps list, for
	42	* synchronization between readers and writer, RCU is used.
	43	*/
	44	static DEFINE_SPINLOCK(acpi_iomaps_lock);
	45
	46	struct acpi_iomap {
	47	struct list_head list;
	48	void __iomem *vaddr;
	49	unsigned long size;
	50	phys_addr_t paddr;
	51	struct kref ref;
	52	};
	53
	54	/* acpi_iomaps_lock or RCU read lock must be held before calling */
	55	static struct acpi_iomap *__acpi_find_iomap(phys_addr_t paddr,
	56	unsigned long size)
	57	{
	58	struct acpi_iomap *map;
	59
	60	list_for_each_entry_rcu(map, &acpi_iomaps, list) {
	61	if (map->paddr + map->size >= paddr + size &&
	62	map->paddr <= paddr)
	63	return map;
	64	}
	65	return NULL;
	66	}
	67
	68	/*
	69	* Atomic "ioremap" used by NMI handler, if the specified IO memory
	70	* area is not pre-mapped, NULL will be returned.
	71	*
	72	* acpi_iomaps_lock or RCU read lock must be held before calling
	73	*/
	74	static void __iomem *__acpi_ioremap_fast(phys_addr_t paddr,
	75	unsigned long size)
	76	{
	77	struct acpi_iomap *map;
	78
	79	map = __acpi_find_iomap(paddr, size);
	80	if (map)
	81	return map->vaddr + (paddr - map->paddr);
	82	else
	83	return NULL;
	84	}
	85
	86	/* acpi_iomaps_lock must be held before calling */
	87	static void __iomem *__acpi_try_ioremap(phys_addr_t paddr,
	88	unsigned long size)
	89	{
	90	struct acpi_iomap *map;
	91
	92	map = __acpi_find_iomap(paddr, size);
	93	if (map) {
	94	kref_get(&map->ref);
	95	return map->vaddr + (paddr - map->paddr);
	96	} else
	97	return NULL;
	98	}
99
100	/*
101	* Used to pre-map the specified IO memory area. First try to find
102	* whether the area is already pre-mapped, if it is, increase the
103	* reference count (in __acpi_try_ioremap) and return; otherwise, do
104	* the real ioremap, and add the mapping into acpi_iomaps list.
105	*/
106	static void __iomem *acpi_pre_map(phys_addr_t paddr,
107	unsigned long size)
108	{
109	void __iomem *vaddr;
110	struct acpi_iomap *map;
111	unsigned long pg_sz, flags;
112	phys_addr_t pg_off;
113
114	spin_lock_irqsave(&acpi_iomaps_lock, flags);
115	vaddr = __acpi_try_ioremap(paddr, size);
116	spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
117	if (vaddr)
118	return vaddr;
119
120	pg_off = paddr & PAGE_MASK;
121	pg_sz = ((paddr + size + PAGE_SIZE - 1) & PAGE_MASK) - pg_off;
122	vaddr = ioremap(pg_off, pg_sz);
123	if (!vaddr)
124	return NULL;
125	map = kmalloc(sizeof(*map), GFP_KERNEL);
126	if (!map)
127	goto err_unmap;
128	INIT_LIST_HEAD(&map->list);
129	map->paddr = pg_off;
130	map->size = pg_sz;
131	map->vaddr = vaddr;
132	kref_init(&map->ref);
133
134	spin_lock_irqsave(&acpi_iomaps_lock, flags);
135	vaddr = __acpi_try_ioremap(paddr, size);
136	if (vaddr) {
137	spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
138	iounmap(map->vaddr);
139	kfree(map);
140	return vaddr;
141	}
142	list_add_tail_rcu(&map->list, &acpi_iomaps);
143	spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
144
145	return vaddr + (paddr - pg_off);
146	err_unmap:
147	iounmap(vaddr);
148	return NULL;
149	}
150
151	/* acpi_iomaps_lock must be held before calling */
152	static void __acpi_kref_del_iomap(struct kref *ref)
153	{
154	struct acpi_iomap *map;
155
156	map = container_of(ref, struct acpi_iomap, ref);
157	list_del_rcu(&map->list);
158	}
159
160	/*
161	* Used to post-unmap the specified IO memory area. The iounmap is
162	* done only if the reference count goes zero.
163	*/
164	static void acpi_post_unmap(phys_addr_t paddr, unsigned long size)
165	{
166	struct acpi_iomap *map;
167	unsigned long flags;
168	int del;
169
170	spin_lock_irqsave(&acpi_iomaps_lock, flags);
171	map = __acpi_find_iomap(paddr, size);
172	BUG_ON(!map);
173	del = kref_put(&map->ref, __acpi_kref_del_iomap);
174	spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
175
176	if (!del)
177	return;
178
179	synchronize_rcu();
180	iounmap(map->vaddr);
181	kfree(map);
182	}
183
184	/* In NMI handler, should set silent = 1 */
185	static int acpi_check_gar(struct acpi_generic_address *reg,
186	u64 *paddr, int silent)
187	{
188	u32 width, space_id;
189
190	width = reg->bit_width;
191	space_id = reg->space_id;
192	/* Handle possible alignment issues */
193	memcpy(paddr, &reg->address, sizeof(*paddr));
194	if (!*paddr) {
195	if (!silent)
196	pr_warning(FW_BUG ACPI_PFX
197	"Invalid physical address in GAR [0x%llx/%u/%u]\n",
198	*paddr, width, space_id);
199	return -EINVAL;
200	}
201
202	if ((width != 8) && (width != 16) && (width != 32) && (width != 64)) {
203	if (!silent)
204	pr_warning(FW_BUG ACPI_PFX
205	"Invalid bit width in GAR [0x%llx/%u/%u]\n",
206	*paddr, width, space_id);
207	return -EINVAL;
208	}
209
210	if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY &&
211	space_id != ACPI_ADR_SPACE_SYSTEM_IO) {
212	if (!silent)
213	pr_warning(FW_BUG ACPI_PFX
214	"Invalid address space type in GAR [0x%llx/%u/%u]\n",
215	*paddr, width, space_id);
216	return -EINVAL;
217	}
218
219	return 0;
220	}
221
222	/* Pre-map, working on GAR */
223	int acpi_pre_map_gar(struct acpi_generic_address *reg)
224	{
225	u64 paddr;
226	void __iomem *vaddr;
227	int rc;
228
229	if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
230	return 0;
231
232	rc = acpi_check_gar(reg, &paddr, 0);
233	if (rc)
234	return rc;
235
236	vaddr = acpi_pre_map(paddr, reg->bit_width / 8);
237	if (!vaddr)
238	return -EIO;
239
240	return 0;
241	}
242	EXPORT_SYMBOL_GPL(acpi_pre_map_gar);
243
244	/* Post-unmap, working on GAR */
245	int acpi_post_unmap_gar(struct acpi_generic_address *reg)
246	{
247	u64 paddr;
248	int rc;
249
250	if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
251	return 0;
252
253	rc = acpi_check_gar(reg, &paddr, 0);
254	if (rc)
255	return rc;
256
257	acpi_post_unmap(paddr, reg->bit_width / 8);
258
259	return 0;
260	}
261	EXPORT_SYMBOL_GPL(acpi_post_unmap_gar);
262
263	/*
264	* Can be used in atomic (including NMI) or process context. RCU read
265	* lock can only be released after the IO memory area accessing.
266	*/
267	static int acpi_atomic_read_mem(u64 paddr, u64 *val, u32 width)
268	{
269	void __iomem *addr;
270
271	rcu_read_lock();
272	addr = __acpi_ioremap_fast(paddr, width);
273	switch (width) {
274	case 8:
275	*val = readb(addr);
276	break;
277	case 16:
278	*val = readw(addr);
279	break;
280	case 32:
281	*val = readl(addr);
282	break;
283	case 64:
284	*val = readq(addr);
285	break;
286	default:
287	return -EINVAL;
288	}
289	rcu_read_unlock();
290
291	return 0;
292	}
293
294	static int acpi_atomic_write_mem(u64 paddr, u64 val, u32 width)
295	{
296	void __iomem *addr;
297
298	rcu_read_lock();
299	addr = __acpi_ioremap_fast(paddr, width);
300	switch (width) {
301	case 8:
302	writeb(val, addr);
303	break;
304	case 16:
305	writew(val, addr);
306	break;
307	case 32:
308	writel(val, addr);
309	break;
310	case 64:
311	writeq(val, addr);
312	break;
313	default:
314	return -EINVAL;
315	}
316	rcu_read_unlock();
317
318	return 0;
319	}
320
321	/* GAR accessing in atomic (including NMI) or process context */
322	int acpi_atomic_read(u64 val, struct acpi_generic_address reg)
323	{
324	u64 paddr;
325	int rc;
326
327	rc = acpi_check_gar(reg, &paddr, 1);
328	if (rc)
329	return rc;
330
331	*val = 0;
332	switch (reg->space_id) {
333	case ACPI_ADR_SPACE_SYSTEM_MEMORY:
334	return acpi_atomic_read_mem(paddr, val, reg->bit_width);
335	case ACPI_ADR_SPACE_SYSTEM_IO:
336	return acpi_os_read_port(paddr, (u32 *)val, reg->bit_width);
337	default:
338	return -EINVAL;
339	}
340	}
341	EXPORT_SYMBOL_GPL(acpi_atomic_read);
342
343	int acpi_atomic_write(u64 val, struct acpi_generic_address *reg)
344	{
345	u64 paddr;
346	int rc;
347
348	rc = acpi_check_gar(reg, &paddr, 1);
349	if (rc)
350	return rc;
351
352	switch (reg->space_id) {
353	case ACPI_ADR_SPACE_SYSTEM_MEMORY:
354	return acpi_atomic_write_mem(paddr, val, reg->bit_width);
355	case ACPI_ADR_SPACE_SYSTEM_IO:
356	return acpi_os_write_port(paddr, val, reg->bit_width);
357	default:
358	return -EINVAL;
359	}
360	}
361	EXPORT_SYMBOL_GPL(acpi_atomic_write);