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