[deliverable/linux.git] / arch / sh / mm / pmb.c

/*
 * arch/sh/mm/pmb.c
 *
 * Privileged Space Mapping Buffer (PMB) Support.
 *
 * Copyright (C) 2005 - 2010  Paul Mundt
 * Copyright (C) 2010  Matt Fleming
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sysdev.h>
#include <linux/cpu.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/bitops.h>
#include <linux/debugfs.h>
#include <linux/fs.h>
#include <linux/seq_file.h>
#include <linux/err.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <asm/pgtable.h>
#include <asm/mmu.h>
#include <asm/io.h>
#include <asm/mmu_context.h>

#define NR_PMB_ENTRIES	16

static void __pmb_unmap(struct pmb_entry *);

static struct pmb_entry pmb_entry_list[NR_PMB_ENTRIES];
static unsigned long pmb_map;

static inline unsigned long mk_pmb_entry(unsigned int entry)
{
	return (entry & PMB_E_MASK) << PMB_E_SHIFT;
}

static inline unsigned long mk_pmb_addr(unsigned int entry)
{
	return mk_pmb_entry(entry) | PMB_ADDR;
}

static inline unsigned long mk_pmb_data(unsigned int entry)
{
	return mk_pmb_entry(entry) | PMB_DATA;
}

static int pmb_alloc_entry(void)
{
	unsigned int pos;

repeat:
	pos = find_first_zero_bit(&pmb_map, NR_PMB_ENTRIES);

	if (unlikely(pos > NR_PMB_ENTRIES))
		return -ENOSPC;

	if (test_and_set_bit(pos, &pmb_map))
		goto repeat;

	return pos;
}

static struct pmb_entry *pmb_alloc(unsigned long vpn, unsigned long ppn,
				   unsigned long flags, int entry)
{
	struct pmb_entry *pmbe;
	int pos;

	if (entry == PMB_NO_ENTRY) {
		pos = pmb_alloc_entry();
		if (pos < 0)
			return ERR_PTR(pos);
	} else {
		if (test_bit(entry, &pmb_map))
			return ERR_PTR(-ENOSPC);
		pos = entry;
	}

	pmbe = &pmb_entry_list[pos];
	if (!pmbe)
		return ERR_PTR(-ENOMEM);

	pmbe->vpn	= vpn;
	pmbe->ppn	= ppn;
	pmbe->flags	= flags;
	pmbe->entry	= pos;

	return pmbe;
}

static void pmb_free(struct pmb_entry *pmbe)
{
	int pos = pmbe->entry;

	pmbe->vpn	= 0;
	pmbe->ppn	= 0;
	pmbe->flags	= 0;
	pmbe->entry	= 0;

	clear_bit(pos, &pmb_map);
}

/*
 * Must be in P2 for __set_pmb_entry()
 */
static void __set_pmb_entry(unsigned long vpn, unsigned long ppn,
			    unsigned long flags, int pos)
{
	__raw_writel(vpn | PMB_V, mk_pmb_addr(pos));

#ifdef CONFIG_CACHE_WRITETHROUGH
	/*
	 * When we are in 32-bit address extended mode, CCR.CB becomes
	 * invalid, so care must be taken to manually adjust cacheable
	 * translations.
	 */
	if (likely(flags & PMB_C))
		flags |= PMB_WT;
#endif

	__raw_writel(ppn | flags | PMB_V, mk_pmb_data(pos));
}

static void set_pmb_entry(struct pmb_entry *pmbe)
{
	jump_to_uncached();
	__set_pmb_entry(pmbe->vpn, pmbe->ppn, pmbe->flags, pmbe->entry);
	back_to_cached();
}

static void clear_pmb_entry(struct pmb_entry *pmbe)
{
	unsigned int entry = pmbe->entry;
	unsigned long addr;

	if (unlikely(entry >= NR_PMB_ENTRIES))
		return;

	jump_to_uncached();

	/* Clear V-bit */
	addr = mk_pmb_addr(entry);
	__raw_writel(__raw_readl(addr) & ~PMB_V, addr);

	addr = mk_pmb_data(entry);
	__raw_writel(__raw_readl(addr) & ~PMB_V, addr);

	back_to_cached();
}


static struct {
	unsigned long size;
	int flag;
} pmb_sizes[] = {
	{ .size	= 0x20000000, .flag = PMB_SZ_512M, },
	{ .size = 0x08000000, .flag = PMB_SZ_128M, },
	{ .size = 0x04000000, .flag = PMB_SZ_64M,  },
	{ .size = 0x01000000, .flag = PMB_SZ_16M,  },
};

long pmb_remap(unsigned long vaddr, unsigned long phys,
	       unsigned long size, unsigned long flags)
{
	struct pmb_entry *pmbp, *pmbe;
	unsigned long wanted;
	int pmb_flags, i;
	long err;

	/* Convert typical pgprot value to the PMB equivalent */
	if (flags & _PAGE_CACHABLE) {
		if (flags & _PAGE_WT)
			pmb_flags = PMB_WT;
		else
			pmb_flags = PMB_C;
	} else
		pmb_flags = PMB_WT | PMB_UB;

	pmbp = NULL;
	wanted = size;

again:
	for (i = 0; i < ARRAY_SIZE(pmb_sizes); i++) {
		if (size < pmb_sizes[i].size)
			continue;

		pmbe = pmb_alloc(vaddr, phys, pmb_flags | pmb_sizes[i].flag,
				 PMB_NO_ENTRY);
		if (IS_ERR(pmbe)) {
			err = PTR_ERR(pmbe);
			goto out;
		}

		set_pmb_entry(pmbe);

		phys	+= pmb_sizes[i].size;
		vaddr	+= pmb_sizes[i].size;
		size	-= pmb_sizes[i].size;

		/*
		 * Link adjacent entries that span multiple PMB entries
		 * for easier tear-down.
		 */
		if (likely(pmbp))
			pmbp->link = pmbe;

		pmbp = pmbe;

		/*
		 * Instead of trying smaller sizes on every iteration
		 * (even if we succeed in allocating space), try using
		 * pmb_sizes[i].size again.
		 */
		i--;
	}

	if (size >= 0x1000000)
		goto again;

	return wanted - size;

out:
	if (pmbp)
		__pmb_unmap(pmbp);

	return err;
}

void pmb_unmap(unsigned long addr)
{
	struct pmb_entry *pmbe = NULL;
	int i;

	for (i = 0; i < ARRAY_SIZE(pmb_entry_list); i++) {
		if (test_bit(i, &pmb_map)) {
			pmbe = &pmb_entry_list[i];
			if (pmbe->vpn == addr)
				break;
		}
	}

	if (unlikely(!pmbe))
		return;

	__pmb_unmap(pmbe);
}

static void __pmb_unmap(struct pmb_entry *pmbe)
{
	BUG_ON(!test_bit(pmbe->entry, &pmb_map));

	do {
		struct pmb_entry *pmblink = pmbe;

		/*
		 * We may be called before this pmb_entry has been
		 * entered into the PMB table via set_pmb_entry(), but
		 * that's OK because we've allocated a unique slot for
		 * this entry in pmb_alloc() (even if we haven't filled
		 * it yet).
		 *
		 * Therefore, calling clear_pmb_entry() is safe as no
		 * other mapping can be using that slot.
		 */
		clear_pmb_entry(pmbe);

		pmbe = pmblink->link;

		pmb_free(pmblink);
	} while (pmbe);
}

#ifdef CONFIG_PMB_LEGACY
static inline unsigned int pmb_ppn_in_range(unsigned long ppn)
{
	return ppn >= __MEMORY_START && ppn < __MEMORY_START + __MEMORY_SIZE;
}

static int pmb_apply_legacy_mappings(void)
{
	unsigned int applied = 0;
	int i;

	pr_info("PMB: Preserving legacy mappings:\n");

	/*
	 * The following entries are setup by the bootloader.
	 *
	 * Entry       VPN	   PPN	    V	SZ	C	UB
	 * --------------------------------------------------------
	 *   0      0xA0000000 0x00000000   1   64MB    0       0
	 *   1      0xA4000000 0x04000000   1   16MB    0       0
	 *   2      0xA6000000 0x08000000   1   16MB    0       0
	 *   9      0x88000000 0x48000000   1  128MB    1       1
	 *  10      0x90000000 0x50000000   1  128MB    1       1
	 *  11      0x98000000 0x58000000   1  128MB    1       1
	 *  13      0xA8000000 0x48000000   1  128MB    0       0
	 *  14      0xB0000000 0x50000000   1  128MB    0       0
	 *  15      0xB8000000 0x58000000   1  128MB    0       0
	 *
	 * The only entries the we need are the ones that map the kernel
	 * at the cached and uncached addresses.
	 */
	for (i = 0; i < PMB_ENTRY_MAX; i++) {
		unsigned long addr, data;
		unsigned long addr_val, data_val;
		unsigned long ppn, vpn;

		addr = mk_pmb_addr(i);
		data = mk_pmb_data(i);

		addr_val = __raw_readl(addr);
		data_val = __raw_readl(data);

		/*
		 * Skip over any bogus entries
		 */
		if (!(data_val & PMB_V) || !(addr_val & PMB_V))
			continue;

		ppn = data_val & PMB_PFN_MASK;
		vpn = addr_val & PMB_PFN_MASK;

		/*
		 * Only preserve in-range mappings.
		 */
		if (pmb_ppn_in_range(ppn)) {
			unsigned int size;
			char *sz_str = NULL;

			size = data_val & PMB_SZ_MASK;

			sz_str = (size == PMB_SZ_16M)  ? " 16MB":
				 (size == PMB_SZ_64M)  ? " 64MB":
				 (size == PMB_SZ_128M) ? "128MB":
							 "512MB";

			pr_info("\t0x%08lx -> 0x%08lx [ %s %scached ]\n",
				vpn >> PAGE_SHIFT, ppn >> PAGE_SHIFT, sz_str,
				(data_val & PMB_C) ? "" : "un");

			applied++;
		} else {
			/*
			 * Invalidate anything out of bounds.
			 */
			__raw_writel(addr_val & ~PMB_V, addr);
			__raw_writel(data_val & ~PMB_V, data);
		}
	}

	return (applied == 0);
}
#else
static inline int pmb_apply_legacy_mappings(void)
{
	return 1;
}
#endif

int pmb_init(void)
{
	int i;
	unsigned long addr, data;
	unsigned long ret;

	jump_to_uncached();

	/*
	 * Attempt to apply the legacy boot mappings if configured. If
	 * this is successful then we simply carry on with those and
	 * don't bother establishing additional memory mappings. Dynamic
	 * device mappings through pmb_remap() can still be bolted on
	 * after this.
	 */
	ret = pmb_apply_legacy_mappings();
	if (ret == 0) {
		back_to_cached();
		return 0;
	}

	/*
	 * Sync our software copy of the PMB mappings with those in
	 * hardware. The mappings in the hardware PMB were either set up
	 * by the bootloader or very early on by the kernel.
	 */
	for (i = 0; i < PMB_ENTRY_MAX; i++) {
		struct pmb_entry *pmbe;
		unsigned long vpn, ppn, flags;

		addr = PMB_DATA + (i << PMB_E_SHIFT);
		data = __raw_readl(addr);
		if (!(data & PMB_V))
			continue;

		if (data & PMB_C) {
#if defined(CONFIG_CACHE_WRITETHROUGH)
			data |= PMB_WT;
#elif defined(CONFIG_CACHE_WRITEBACK)
			data &= ~PMB_WT;
#else
			data &= ~(PMB_C | PMB_WT);
#endif
		}
		__raw_writel(data, addr);

		ppn = data & PMB_PFN_MASK;

		flags = data & (PMB_C | PMB_WT | PMB_UB);
		flags |= data & PMB_SZ_MASK;

		addr = PMB_ADDR + (i << PMB_E_SHIFT);
		data = __raw_readl(addr);

		vpn = data & PMB_PFN_MASK;

		pmbe = pmb_alloc(vpn, ppn, flags, i);
		WARN_ON(IS_ERR(pmbe));
	}

	__raw_writel(0, PMB_IRMCR);

	/* Flush out the TLB */
	i =  __raw_readl(MMUCR);
	i |= MMUCR_TI;
	__raw_writel(i, MMUCR);

	back_to_cached();

	return 0;
}

bool __in_29bit_mode(void)
{
        return (__raw_readl(PMB_PASCR) & PASCR_SE) == 0;
}

static int pmb_seq_show(struct seq_file *file, void *iter)
{
	int i;

	seq_printf(file, "V: Valid, C: Cacheable, WT: Write-Through\n"
			 "CB: Copy-Back, B: Buffered, UB: Unbuffered\n");
	seq_printf(file, "ety   vpn  ppn  size   flags\n");

	for (i = 0; i < NR_PMB_ENTRIES; i++) {
		unsigned long addr, data;
		unsigned int size;
		char *sz_str = NULL;

		addr = __raw_readl(mk_pmb_addr(i));
		data = __raw_readl(mk_pmb_data(i));

		size = data & PMB_SZ_MASK;
		sz_str = (size == PMB_SZ_16M)  ? " 16MB":
			 (size == PMB_SZ_64M)  ? " 64MB":
			 (size == PMB_SZ_128M) ? "128MB":
					         "512MB";

		/* 02: V 0x88 0x08 128MB C CB  B */
		seq_printf(file, "%02d: %c 0x%02lx 0x%02lx %s %c %s %s\n",
			   i, ((addr & PMB_V) && (data & PMB_V)) ? 'V' : ' ',
			   (addr >> 24) & 0xff, (data >> 24) & 0xff,
			   sz_str, (data & PMB_C) ? 'C' : ' ',
			   (data & PMB_WT) ? "WT" : "CB",
			   (data & PMB_UB) ? "UB" : " B");
	}

	return 0;
}

static int pmb_debugfs_open(struct inode *inode, struct file *file)
{
	return single_open(file, pmb_seq_show, NULL);
}

static const struct file_operations pmb_debugfs_fops = {
	.owner		= THIS_MODULE,
	.open		= pmb_debugfs_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int __init pmb_debugfs_init(void)
{
	struct dentry *dentry;

	dentry = debugfs_create_file("pmb", S_IFREG | S_IRUGO,
				     sh_debugfs_root, NULL, &pmb_debugfs_fops);
	if (!dentry)
		return -ENOMEM;
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);

	return 0;
}
postcore_initcall(pmb_debugfs_init);

#ifdef CONFIG_PM
static int pmb_sysdev_suspend(struct sys_device *dev, pm_message_t state)
{
	static pm_message_t prev_state;
	int i;

	/* Restore the PMB after a resume from hibernation */
	if (state.event == PM_EVENT_ON &&
	    prev_state.event == PM_EVENT_FREEZE) {
		struct pmb_entry *pmbe;
		for (i = 0; i < ARRAY_SIZE(pmb_entry_list); i++) {
			if (test_bit(i, &pmb_map)) {
				pmbe = &pmb_entry_list[i];
				set_pmb_entry(pmbe);
			}
		}
	}
	prev_state = state;
	return 0;
}

static int pmb_sysdev_resume(struct sys_device *dev)
{
	return pmb_sysdev_suspend(dev, PMSG_ON);
}

static struct sysdev_driver pmb_sysdev_driver = {
	.suspend = pmb_sysdev_suspend,
	.resume = pmb_sysdev_resume,
};

static int __init pmb_sysdev_init(void)
{
	return sysdev_driver_register(&cpu_sysdev_class, &pmb_sysdev_driver);
}
subsys_initcall(pmb_sysdev_init);
#endif
Commit	Line	Data
0c7b1df6 PM	1	/*
	2	* arch/sh/mm/pmb.c
	3	*
	4	* Privileged Space Mapping Buffer (PMB) Support.
	5	*
3d467676 MF	6	* Copyright (C) 2005 - 2010 Paul Mundt
3d467676 MF	7	* Copyright (C) 2010 Matt Fleming
0c7b1df6 PM	8	*
	9	* This file is subject to the terms and conditions of the GNU General Public
	10	* License. See the file "COPYING" in the main directory of this archive
	11	* for more details.
	12	*/
	13	#include <linux/init.h>
	14	#include <linux/kernel.h>
a83c0b73 FV	15	#include <linux/sysdev.h>
a83c0b73 FV	16	#include <linux/cpu.h>
0c7b1df6 PM	17	#include <linux/module.h>
	18	#include <linux/slab.h>
	19	#include <linux/bitops.h>
	20	#include <linux/debugfs.h>
	21	#include <linux/fs.h>
	22	#include <linux/seq_file.h>
	23	#include <linux/err.h>
	24	#include <asm/system.h>
	25	#include <asm/uaccess.h>
d7cdc9e8	26	#include <asm/pgtable.h>
0c7b1df6 PM	27	#include <asm/mmu.h>
0c7b1df6 PM	28	#include <asm/io.h>
eddeeb32	29	#include <asm/mmu_context.h>
0c7b1df6 PM	30
	31	#define NR_PMB_ENTRIES 16
	32
fc2bdefd MF	33	static void __pmb_unmap(struct pmb_entry *);
fc2bdefd MF	34
edd7de80	35	static struct pmb_entry pmb_entry_list[NR_PMB_ENTRIES];
0c7b1df6 PM	36	static unsigned long pmb_map;
0c7b1df6 PM	37
0c7b1df6 PM	38	static inline unsigned long mk_pmb_entry(unsigned int entry)
	39	{
	40	return (entry & PMB_E_MASK) << PMB_E_SHIFT;
	41	}
	42
	43	static inline unsigned long mk_pmb_addr(unsigned int entry)
	44	{
	45	return mk_pmb_entry(entry) \| PMB_ADDR;
	46	}
	47
	48	static inline unsigned long mk_pmb_data(unsigned int entry)
	49	{
	50	return mk_pmb_entry(entry) \| PMB_DATA;
	51	}
	52
067784f6 MF	53	static int pmb_alloc_entry(void)
	54	{
	55	unsigned int pos;
	56
	57	repeat:
	58	pos = find_first_zero_bit(&pmb_map, NR_PMB_ENTRIES);
	59
	60	if (unlikely(pos > NR_PMB_ENTRIES))
	61	return -ENOSPC;
	62
	63	if (test_and_set_bit(pos, &pmb_map))
	64	goto repeat;
	65
	66	return pos;
	67	}
	68
8386aebb	69	static struct pmb_entry *pmb_alloc(unsigned long vpn, unsigned long ppn,
20b5014b	70	unsigned long flags, int entry)
0c7b1df6 PM	71	{
0c7b1df6 PM	72	struct pmb_entry *pmbe;
067784f6 MF	73	int pos;
067784f6 MF	74
20b5014b MF	75	if (entry == PMB_NO_ENTRY) {
	76	pos = pmb_alloc_entry();
	77	if (pos < 0)
	78	return ERR_PTR(pos);
	79	} else {
	80	if (test_bit(entry, &pmb_map))
	81	return ERR_PTR(-ENOSPC);
	82	pos = entry;
	83	}
0c7b1df6	84
edd7de80	85	pmbe = &pmb_entry_list[pos];
0c7b1df6 PM	86	if (!pmbe)
	87	return ERR_PTR(-ENOMEM);
	88
	89	pmbe->vpn = vpn;
	90	pmbe->ppn = ppn;
	91	pmbe->flags = flags;
067784f6	92	pmbe->entry = pos;
0c7b1df6 PM	93
	94	return pmbe;
	95	}
	96
8386aebb	97	static void pmb_free(struct pmb_entry *pmbe)
0c7b1df6	98	{
edd7de80	99	int pos = pmbe->entry;
38c425f6	100
edd7de80 MF	101	pmbe->vpn = 0;
	102	pmbe->ppn = 0;
	103	pmbe->flags = 0;
	104	pmbe->entry = 0;
	105
	106	clear_bit(pos, &pmb_map);
0c7b1df6 PM	107	}
	108
	109	/*
	110	* Must be in P2 for __set_pmb_entry()
	111	*/
8386aebb MF	112	static void __set_pmb_entry(unsigned long vpn, unsigned long ppn,
8386aebb MF	113	unsigned long flags, int pos)
0c7b1df6	114	{
9d56dd3b	115	__raw_writel(vpn \| PMB_V, mk_pmb_addr(pos));
0c7b1df6	116
e7bd34a1	117	#ifdef CONFIG_CACHE_WRITETHROUGH
0c7b1df6 PM	118	/*
	119	* When we are in 32-bit address extended mode, CCR.CB becomes
	120	* invalid, so care must be taken to manually adjust cacheable
	121	* translations.
	122	*/
	123	if (likely(flags & PMB_C))
	124	flags \|= PMB_WT;
	125	#endif
	126
9d56dd3b	127	__raw_writel(ppn \| flags \| PMB_V, mk_pmb_data(pos));
0c7b1df6 PM	128	}
0c7b1df6 PM	129
2dc2f8e0	130	static void set_pmb_entry(struct pmb_entry *pmbe)
0c7b1df6	131	{
cbaa118e	132	jump_to_uncached();
067784f6	133	__set_pmb_entry(pmbe->vpn, pmbe->ppn, pmbe->flags, pmbe->entry);
cbaa118e	134	back_to_cached();
0c7b1df6 PM	135	}
0c7b1df6 PM	136
2dc2f8e0	137	static void clear_pmb_entry(struct pmb_entry *pmbe)
0c7b1df6 PM	138	{
	139	unsigned int entry = pmbe->entry;
	140	unsigned long addr;
	141
31051219	142	if (unlikely(entry >= NR_PMB_ENTRIES))
0c7b1df6 PM	143	return;
0c7b1df6 PM	144
cbaa118e	145	jump_to_uncached();
0c7b1df6 PM	146
	147	/* Clear V-bit */
	148	addr = mk_pmb_addr(entry);
9d56dd3b	149	__raw_writel(__raw_readl(addr) & ~PMB_V, addr);
0c7b1df6 PM	150
0c7b1df6 PM	151	addr = mk_pmb_data(entry);
9d56dd3b	152	__raw_writel(__raw_readl(addr) & ~PMB_V, addr);
0c7b1df6	153
cbaa118e	154	back_to_cached();
0c7b1df6 PM	155	}
0c7b1df6 PM	156
d7cdc9e8 PM	157
	158	static struct {
	159	unsigned long size;
	160	int flag;
	161	} pmb_sizes[] = {
	162	{ .size = 0x20000000, .flag = PMB_SZ_512M, },
	163	{ .size = 0x08000000, .flag = PMB_SZ_128M, },
	164	{ .size = 0x04000000, .flag = PMB_SZ_64M, },
	165	{ .size = 0x01000000, .flag = PMB_SZ_16M, },
	166	};
	167
	168	long pmb_remap(unsigned long vaddr, unsigned long phys,
	169	unsigned long size, unsigned long flags)
	170	{
fc2bdefd	171	struct pmb_entry pmbp, pmbe;
d7cdc9e8 PM	172	unsigned long wanted;
d7cdc9e8 PM	173	int pmb_flags, i;
fc2bdefd	174	long err;
d7cdc9e8 PM	175
	176	/* Convert typical pgprot value to the PMB equivalent */
	177	if (flags & _PAGE_CACHABLE) {
	178	if (flags & _PAGE_WT)
	179	pmb_flags = PMB_WT;
	180	else
	181	pmb_flags = PMB_C;
	182	} else
	183	pmb_flags = PMB_WT \| PMB_UB;
	184
	185	pmbp = NULL;
	186	wanted = size;
	187
	188	again:
	189	for (i = 0; i < ARRAY_SIZE(pmb_sizes); i++) {
d7cdc9e8 PM	190	if (size < pmb_sizes[i].size)
	191	continue;
	192
20b5014b MF	193	pmbe = pmb_alloc(vaddr, phys, pmb_flags \| pmb_sizes[i].flag,
20b5014b MF	194	PMB_NO_ENTRY);
fc2bdefd MF	195	if (IS_ERR(pmbe)) {
	196	err = PTR_ERR(pmbe);
	197	goto out;
	198	}
d7cdc9e8	199
067784f6	200	set_pmb_entry(pmbe);
d7cdc9e8 PM	201
	202	phys += pmb_sizes[i].size;
	203	vaddr += pmb_sizes[i].size;
	204	size -= pmb_sizes[i].size;
	205
	206	/*
	207	* Link adjacent entries that span multiple PMB entries
	208	* for easier tear-down.
	209	*/
	210	if (likely(pmbp))
	211	pmbp->link = pmbe;
	212
	213	pmbp = pmbe;
a2767cfb MF	214
	215	/*
	216	* Instead of trying smaller sizes on every iteration
	217	* (even if we succeed in allocating space), try using
	218	* pmb_sizes[i].size again.
	219	*/
	220	i--;
d7cdc9e8 PM	221	}
	222
	223	if (size >= 0x1000000)
	224	goto again;
	225
	226	return wanted - size;
fc2bdefd MF	227
	228	out:
	229	if (pmbp)
	230	__pmb_unmap(pmbp);
	231
	232	return err;
d7cdc9e8 PM	233	}
	234
	235	void pmb_unmap(unsigned long addr)
	236	{
edd7de80 MF	237	struct pmb_entry *pmbe = NULL;
edd7de80 MF	238	int i;
d7cdc9e8	239
edd7de80 MF	240	for (i = 0; i < ARRAY_SIZE(pmb_entry_list); i++) {
	241	if (test_bit(i, &pmb_map)) {
	242	pmbe = &pmb_entry_list[i];
	243	if (pmbe->vpn == addr)
	244	break;
	245	}
	246	}
d7cdc9e8 PM	247
	248	if (unlikely(!pmbe))
	249	return;
	250
fc2bdefd MF	251	__pmb_unmap(pmbe);
	252	}
	253
	254	static void __pmb_unmap(struct pmb_entry *pmbe)
	255	{
edd7de80	256	BUG_ON(!test_bit(pmbe->entry, &pmb_map));
d7cdc9e8 PM	257
	258	do {
	259	struct pmb_entry *pmblink = pmbe;
	260
067784f6 MF	261	/*
	262	* We may be called before this pmb_entry has been
	263	* entered into the PMB table via set_pmb_entry(), but
	264	* that's OK because we've allocated a unique slot for
	265	* this entry in pmb_alloc() (even if we haven't filled
	266	* it yet).
	267	*
	268	* Therefore, calling clear_pmb_entry() is safe as no
	269	* other mapping can be using that slot.
	270	*/
	271	clear_pmb_entry(pmbe);
fc2bdefd	272
d7cdc9e8 PM	273	pmbe = pmblink->link;
	274
	275	pmb_free(pmblink);
	276	} while (pmbe);
	277	}
	278
a0ab3668	279	#ifdef CONFIG_PMB_LEGACY
3d467676 MF	280	static inline unsigned int pmb_ppn_in_range(unsigned long ppn)
	281	{
	282	return ppn >= __MEMORY_START && ppn < __MEMORY_START + __MEMORY_SIZE;
	283	}
	284
a0ab3668	285	static int pmb_apply_legacy_mappings(void)
20b5014b	286	{
a0ab3668	287	unsigned int applied = 0;
3d467676	288	int i;
20b5014b	289
3d467676	290	pr_info("PMB: Preserving legacy mappings:\n");
20b5014b	291
3d467676 MF	292	/*
	293	* The following entries are setup by the bootloader.
	294	*
	295	* Entry VPN PPN V SZ C UB
	296	* --------------------------------------------------------
	297	* 0 0xA0000000 0x00000000 1 64MB 0 0
	298	* 1 0xA4000000 0x04000000 1 16MB 0 0
	299	* 2 0xA6000000 0x08000000 1 16MB 0 0
	300	* 9 0x88000000 0x48000000 1 128MB 1 1
	301	* 10 0x90000000 0x50000000 1 128MB 1 1
	302	* 11 0x98000000 0x58000000 1 128MB 1 1
	303	* 13 0xA8000000 0x48000000 1 128MB 0 0
	304	* 14 0xB0000000 0x50000000 1 128MB 0 0
	305	* 15 0xB8000000 0x58000000 1 128MB 0 0
	306	*
	307	* The only entries the we need are the ones that map the kernel
	308	* at the cached and uncached addresses.
	309	*/
	310	for (i = 0; i < PMB_ENTRY_MAX; i++) {
	311	unsigned long addr, data;
	312	unsigned long addr_val, data_val;
	313	unsigned long ppn, vpn;
20b5014b	314
3d467676 MF	315	addr = mk_pmb_addr(i);
3d467676 MF	316	data = mk_pmb_data(i);
20b5014b	317
3d467676 MF	318	addr_val = __raw_readl(addr);
3d467676 MF	319	data_val = __raw_readl(data);
20b5014b	320
3d467676 MF	321	/*
	322	* Skip over any bogus entries
	323	*/
	324	if (!(data_val & PMB_V) \|\| !(addr_val & PMB_V))
	325	continue;
20b5014b	326
3d467676 MF	327	ppn = data_val & PMB_PFN_MASK;
3d467676 MF	328	vpn = addr_val & PMB_PFN_MASK;
a0ab3668	329
3d467676 MF	330	/*
	331	* Only preserve in-range mappings.
	332	*/
	333	if (pmb_ppn_in_range(ppn)) {
	334	unsigned int size;
	335	char *sz_str = NULL;
	336
	337	size = data_val & PMB_SZ_MASK;
	338
	339	sz_str = (size == PMB_SZ_16M) ? " 16MB":
	340	(size == PMB_SZ_64M) ? " 64MB":
	341	(size == PMB_SZ_128M) ? "128MB":
	342	"512MB";
	343
	344	pr_info("\t0x%08lx -> 0x%08lx [ %s %scached ]\n",
	345	vpn >> PAGE_SHIFT, ppn >> PAGE_SHIFT, sz_str,
	346	(data_val & PMB_C) ? "" : "un");
	347
	348	applied++;
	349	} else {
	350	/*
	351	* Invalidate anything out of bounds.
	352	*/
	353	__raw_writel(addr_val & ~PMB_V, addr);
	354	__raw_writel(data_val & ~PMB_V, data);
	355	}
a0ab3668 PM	356	}
	357
	358	return (applied == 0);
	359	}
	360	#else
	361	static inline int pmb_apply_legacy_mappings(void)
	362	{
	363	return 1;
	364	}
	365	#endif
	366
2dc2f8e0	367	int pmb_init(void)
a0ab3668	368	{
3d467676 MF	369	int i;
	370	unsigned long addr, data;
	371	unsigned long ret;
a0ab3668 PM	372
	373	jump_to_uncached();
	374
	375	/*
	376	* Attempt to apply the legacy boot mappings if configured. If
	377	* this is successful then we simply carry on with those and
	378	* don't bother establishing additional memory mappings. Dynamic
	379	* device mappings through pmb_remap() can still be bolted on
	380	* after this.
	381	*/
	382	ret = pmb_apply_legacy_mappings();
	383	if (ret == 0) {
	384	back_to_cached();
	385	return 0;
20b5014b MF	386	}
20b5014b MF	387
a0ab3668	388	/*
3d467676 MF	389	* Sync our software copy of the PMB mappings with those in
	390	* hardware. The mappings in the hardware PMB were either set up
	391	* by the bootloader or very early on by the kernel.
a0ab3668	392	*/
3d467676 MF	393	for (i = 0; i < PMB_ENTRY_MAX; i++) {
	394	struct pmb_entry *pmbe;
	395	unsigned long vpn, ppn, flags;
a0ab3668	396
3d467676	397	addr = PMB_DATA + (i << PMB_E_SHIFT);
9d56dd3b	398	data = __raw_readl(addr);
3d467676 MF	399	if (!(data & PMB_V))
3d467676 MF	400	continue;
a0ab3668	401
3d467676 MF	402	if (data & PMB_C) {
	403	#if defined(CONFIG_CACHE_WRITETHROUGH)
	404	data \|= PMB_WT;
	405	#elif defined(CONFIG_CACHE_WRITEBACK)
	406	data &= ~PMB_WT;
	407	#else
	408	data &= ~(PMB_C \| PMB_WT);
	409	#endif
	410	}
9d56dd3b	411	__raw_writel(data, addr);
a0ab3668	412
3d467676 MF	413	ppn = data & PMB_PFN_MASK;
	414
	415	flags = data & (PMB_C \| PMB_WT \| PMB_UB);
	416	flags \|= data & PMB_SZ_MASK;
a0ab3668	417
3d467676	418	addr = PMB_ADDR + (i << PMB_E_SHIFT);
9d56dd3b	419	data = __raw_readl(addr);
3d467676 MF	420
	421	vpn = data & PMB_PFN_MASK;
	422
	423	pmbe = pmb_alloc(vpn, ppn, flags, i);
	424	WARN_ON(IS_ERR(pmbe));
	425	}
	426
9d56dd3b	427	__raw_writel(0, PMB_IRMCR);
a0ab3668 PM	428
a0ab3668 PM	429	/* Flush out the TLB */
9d56dd3b	430	i = __raw_readl(MMUCR);
a0ab3668	431	i \|= MMUCR_TI;
9d56dd3b	432	__raw_writel(i, MMUCR);
a0ab3668	433
20b5014b MF	434	back_to_cached();
	435
	436	return 0;
	437	}
0c7b1df6	438
2efa53b2 PM	439	bool __in_29bit_mode(void)
	440	{
	441	return (__raw_readl(PMB_PASCR) & PASCR_SE) == 0;
	442	}
	443
0c7b1df6 PM	444	static int pmb_seq_show(struct seq_file file, void iter)
	445	{
	446	int i;
	447
	448	seq_printf(file, "V: Valid, C: Cacheable, WT: Write-Through\n"
	449	"CB: Copy-Back, B: Buffered, UB: Unbuffered\n");
	450	seq_printf(file, "ety vpn ppn size flags\n");
	451
	452	for (i = 0; i < NR_PMB_ENTRIES; i++) {
	453	unsigned long addr, data;
	454	unsigned int size;
	455	char *sz_str = NULL;
	456
9d56dd3b PM	457	addr = __raw_readl(mk_pmb_addr(i));
9d56dd3b PM	458	data = __raw_readl(mk_pmb_data(i));
0c7b1df6 PM	459
	460	size = data & PMB_SZ_MASK;
	461	sz_str = (size == PMB_SZ_16M) ? " 16MB":
	462	(size == PMB_SZ_64M) ? " 64MB":
	463	(size == PMB_SZ_128M) ? "128MB":
	464	"512MB";
	465
	466	/* 02: V 0x88 0x08 128MB C CB B */
	467	seq_printf(file, "%02d: %c 0x%02lx 0x%02lx %s %c %s %s\n",
	468	i, ((addr & PMB_V) && (data & PMB_V)) ? 'V' : ' ',
	469	(addr >> 24) & 0xff, (data >> 24) & 0xff,
	470	sz_str, (data & PMB_C) ? 'C' : ' ',
	471	(data & PMB_WT) ? "WT" : "CB",
	472	(data & PMB_UB) ? "UB" : " B");
	473	}
	474
	475	return 0;
	476	}
	477
	478	static int pmb_debugfs_open(struct inode inode, struct file file)
	479	{
	480	return single_open(file, pmb_seq_show, NULL);
	481	}
	482
5dfe4c96	483	static const struct file_operations pmb_debugfs_fops = {
0c7b1df6 PM	484	.owner = THIS_MODULE,
	485	.open = pmb_debugfs_open,
	486	.read = seq_read,
	487	.llseek = seq_lseek,
45dabf14	488	.release = single_release,
0c7b1df6 PM	489	};
	490
	491	static int __init pmb_debugfs_init(void)
	492	{
	493	struct dentry *dentry;
	494
	495	dentry = debugfs_create_file("pmb", S_IFREG \| S_IRUGO,
b9e393c2	496	sh_debugfs_root, NULL, &pmb_debugfs_fops);
25627c7f Z	497	if (!dentry)
25627c7f Z	498	return -ENOMEM;
0c7b1df6 PM	499	if (IS_ERR(dentry))
	500	return PTR_ERR(dentry);
	501
	502	return 0;
	503	}
0c7b1df6	504	postcore_initcall(pmb_debugfs_init);
a83c0b73 FV	505
	506	#ifdef CONFIG_PM
	507	static int pmb_sysdev_suspend(struct sys_device *dev, pm_message_t state)
	508	{
	509	static pm_message_t prev_state;
edd7de80	510	int i;
a83c0b73 FV	511
	512	/* Restore the PMB after a resume from hibernation */
	513	if (state.event == PM_EVENT_ON &&
	514	prev_state.event == PM_EVENT_FREEZE) {
	515	struct pmb_entry *pmbe;
edd7de80 MF	516	for (i = 0; i < ARRAY_SIZE(pmb_entry_list); i++) {
	517	if (test_bit(i, &pmb_map)) {
	518	pmbe = &pmb_entry_list[i];
	519	set_pmb_entry(pmbe);
	520	}
	521	}
a83c0b73 FV	522	}
	523	prev_state = state;
	524	return 0;
	525	}
	526
	527	static int pmb_sysdev_resume(struct sys_device *dev)
	528	{
	529	return pmb_sysdev_suspend(dev, PMSG_ON);
	530	}
	531
	532	static struct sysdev_driver pmb_sysdev_driver = {
	533	.suspend = pmb_sysdev_suspend,
	534	.resume = pmb_sysdev_resume,
	535	};
	536
	537	static int __init pmb_sysdev_init(void)
	538	{
	539	return sysdev_driver_register(&cpu_sysdev_class, &pmb_sysdev_driver);
	540	}
a83c0b73 FV	541	subsys_initcall(pmb_sysdev_init);
a83c0b73 FV	542	#endif