2 * wARM - exporting ARM processor specific privileged services to userspace
5 * Author: GraÅžvydas "notaz" Ignotas
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/proc_fs.h>
15 #include <linux/delay.h>
17 #include <linux/seq_file.h>
19 #include <linux/version.h>
20 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11)
21 #include <linux/uaccess.h>
23 #include <linux/init.h>
24 #include <linux/moduleparam.h>
25 #include <asm/uaccess.h>
27 #define unlocked_ioctl ioctl
34 #ifndef CONFIG_PROC_FS
41 #define WARM_INFO(fmt, ...) \
43 pr_info(PFX fmt, ##__VA_ARGS__)
45 #define SECTION_SIZE 0x100000
46 #define MAX_CACHEOP_RANGE 16384
48 /* assume RAM starts at phys addr 0 (this is really machine specific) */
49 #define RAM_PHYS_START 0
50 #define RAM_MAX_SIZE 0x10000000 /* 256M, try to be future proof */
53 #if defined(CONFIG_CPU_ARM926T)
54 #define EXPECTED_ID 0x069260
55 #elif defined(CONFIG_CPU_ARM920T)
56 #define EXPECTED_ID 0x029200
58 #error "unsupported CPU"
61 extern unsigned long max_mapnr;
63 /* "upper" physical memory, not seen by Linux and to be mmap'ed */
64 static u32 uppermem_start;
65 static u32 uppermem_end;
66 static spinlock_t lock;
70 static u32 *get_pgtable(void)
74 /* get the pointer to the translation table base... */
75 asm ("mrc p15, 0, %0, c2, c0, 0" : "=r"(ttb));
77 return __va((ttb) & 0xffffc000);
80 static int do_set_cb_uppermem(int in_cb, int is_set)
87 if (uppermem_end <= uppermem_start)
90 if (in_cb & WCB_C_BIT)
92 if (in_cb & WCB_B_BIT)
95 spin_lock_irqsave(&lock, flags);
97 pgtable = get_pgtable();
99 for (i = 0; i < 4096; i++)
101 if ((pgtable[i] & 3) != 1)
102 /* must be coarse page table */
105 cpt = __va(pgtable[i] & 0xfffffc00);
107 for (j = 0; j < 256; j++)
116 addr = entry & 0xfffff000;
117 if (uppermem_start <= addr && addr < uppermem_end)
119 pr_debug(PFX "%s C&B bits %08x\n",
120 is_set ? "set" : "clear", entry);
127 /* need to also set AP bits (so that no faults
128 * happen and kernel doesn't touch this after us) */
129 if ((entry & 3) == 3)
130 entry |= 0x030; /* tiny page */
141 warm_drain_wb_inval_tlb();
143 spin_unlock_irqrestore(&lock, flags);
145 WARM_INFO("%c%c bit(s) %s for phys %08x-%08x (%d pages)\n",
146 bits & 8 ? 'c' : ' ', bits & 4 ? 'b' : ' ',
147 is_set ? "set" : "cleared",
148 uppermem_start, uppermem_end - 1, count);
153 static int do_set_cb_virt(int in_cb, int is_set, u32 addr, u32 size)
155 int count = 0, bits = 0;
157 u32 desc1, desc2 = 0;
158 u32 *pgtable, *cpt = NULL;
162 if (in_cb & WCB_C_BIT)
164 if (in_cb & WCB_B_BIT)
167 mask = PAGE_SIZE - 1;
169 size = (size + mask) & ~mask;
171 addr &= ~(PAGE_SIZE - 1);
175 spin_lock_irqsave(&lock, flags);
177 pgtable = get_pgtable();
181 desc1 = pgtable[addr >> 20];
185 spin_unlock_irqrestore(&lock, flags);
186 printk(KERN_WARNING PFX "address %08x not mapped.\n", addr);
190 cpt = __va(desc1 & 0xfffffc00);
191 desc2 = cpt[(addr >> 12) & 0xff];
199 pgtable[addr >> 20] = desc1;
200 addr += SECTION_SIZE;
204 cpt = __va(desc1 & 0xfffff000);
205 desc2 = cpt[(addr >> 10) & 0x3ff];
209 if ((desc2 & 3) == 0) {
210 spin_unlock_irqrestore(&lock, flags);
211 printk(KERN_WARNING PFX "address %08x not mapped (%08x)\n",
221 /* this might be bad idea, better let it fault so that Linux does
222 * it's accounting, but that will drop CB bits, so keep this
223 * for compatibility */
224 if ((desc2 & 3) == 2)
229 cpt[(addr >> 12) & 0xff] = desc2;
232 cpt[(addr >> 10) & 0x3ff] = desc2;
241 warm_drain_wb_inval_tlb();
243 spin_unlock_irqrestore(&lock, flags);
245 WARM_INFO("%c%c bit(s) %s virt %08x-%08x (%d pages)\n",
246 bits & 8 ? 'c' : ' ', bits & 4 ? 'b' : ' ',
247 is_set ? "set" : "cleared", start, end - 1, count);
252 static int do_virt2phys(unsigned long *_addr)
258 pgtable = get_pgtable();
259 desc1 = pgtable[addr >> 20];
262 case 1: /* coarse table */
263 cpt = __va(desc1 & 0xfffffc00);
264 desc2 = cpt[(addr >> 12) & 0xff];
266 case 2: /* 1MB section */
267 *_addr = (desc1 & 0xfff00000) | (addr & 0xfffff);
269 case 3: /* fine table */
270 cpt = __va(desc1 & 0xfffff000);
271 desc2 = cpt[(addr >> 10) & 0x3ff];
278 case 1: /* large page */
279 *_addr = (desc2 & ~0xffff) | (addr & 0xffff);
281 case 2: /* small page */
282 *_addr = (desc2 & ~0x0fff) | (addr & 0x0fff);
284 case 3: /* tiny page */
285 *_addr = (desc2 & ~0x03ff) | (addr & 0x03ff);
294 static int do_cache_ops_whole(int ops)
296 if ((ops & (WOP_D_CLEAN|WOP_D_INVALIDATE)) == (WOP_D_CLEAN|WOP_D_INVALIDATE))
297 warm_cop_clean_inval_d();
299 else if (ops & WOP_D_CLEAN)
302 else if (ops & WOP_D_INVALIDATE) {
303 printk(KERN_WARNING PFX "invalidate without clean is dangerous!\n");
307 if (ops & WOP_I_INVALIDATE)
314 static int do_cache_ops(int ops, u32 addr, u32 size)
322 case WOP_D_CLEAN|WOP_D_INVALIDATE|WOP_I_INVALIDATE:
323 warm_cop_r_clean_d_inval_di(addr, size);
325 case WOP_D_CLEAN|WOP_D_INVALIDATE:
326 warm_cop_r_clean_d_inval_d(addr, size);
328 case WOP_D_CLEAN|WOP_I_INVALIDATE:
329 warm_cop_r_clean_d_inval_i(addr, size);
332 warm_cop_r_clean_d(addr, size);
334 case WOP_D_INVALIDATE|WOP_I_INVALIDATE:
335 warm_cop_r_inval_di(addr, size);
337 case WOP_D_INVALIDATE:
338 warm_cop_r_inval_d(addr, size);
340 case WOP_I_INVALIDATE:
341 warm_cop_r_inval_i(addr, size);
352 static int do_map_op(u32 vaddr, u32 paddr, u32 size, int cb, int is_unmap)
354 int count = 0, retval = 0;
356 u32 pstart, start, end;
357 u32 desc1, apcb_bits;
361 apcb_bits = (3 << 10) | (1 << 5); /* r/w, dom 1 */
367 mask = SECTION_SIZE - 1;
368 size = (size + mask) & ~mask;
374 /* check for overflows */
377 if (pstart + size - 1 < pstart)
380 spin_lock_irqsave(&lock, flags);
382 pgtable = get_pgtable();
384 for (; vaddr < end; vaddr += SECTION_SIZE, paddr += SECTION_SIZE)
386 desc1 = pgtable[vaddr >> 20];
389 if ((desc1 & 3) != 2) {
390 spin_unlock_irqrestore(&lock, flags);
391 printk(KERN_WARNING PFX "vaddr %08x is not a section? (%08x)\n",
397 if ((desc1 & 3) != 0) {
398 printk(KERN_WARNING PFX "vaddr %08x already mapped? (%08x)\n",
403 v = (paddr & ~mask) | apcb_bits | 0x12;
406 pgtable[vaddr >> 20] = v;
414 for (; vaddr < end && count > 0; vaddr += SECTION_SIZE, count--)
415 pgtable[vaddr >> 20] = 0;
419 warm_drain_wb_inval_tlb();
421 spin_unlock_irqrestore(&lock, flags);
423 if (retval == 0 && !is_unmap) {
424 WARM_INFO("mapped %08x to %08x with %c%c bit(s) (%d section(s))\n",
425 start, pstart, apcb_bits & 8 ? 'c' : ' ',
426 apcb_bits & 4 ? 'b' : ' ', count);
432 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11)
433 static long warm_ioctl(struct file *file, unsigned int cmd, unsigned long __arg)
435 static int warm_ioctl(struct inode *inode, struct file *file,
436 unsigned int cmd, unsigned long __arg)
439 void __user *arg = (void __user *) __arg;
441 struct warm_cache_op wcop;
442 struct warm_change_cb ccb;
443 struct warm_map_op mop;
450 if (copy_from_user(&u.wcop, arg, sizeof(u.wcop)))
452 if (u.wcop.ops & ~(WOP_D_CLEAN|WOP_D_INVALIDATE|WOP_I_INVALIDATE))
454 if (u.wcop.size == (unsigned long)-1 ||
455 (u.wcop.size > MAX_CACHEOP_RANGE && !(u.wcop.ops & WOP_D_INVALIDATE)))
456 ret = do_cache_ops_whole(u.wcop.ops);
458 ret = do_cache_ops(u.wcop.ops, u.wcop.addr, u.wcop.size);
460 case WARMC_CHANGE_CB:
461 if (copy_from_user(&u.ccb, arg, sizeof(u.ccb)))
463 if (u.ccb.cb & ~(WCB_C_BIT|WCB_B_BIT))
465 if (u.ccb.addr == 0 && u.ccb.size == 0)
466 ret = do_set_cb_uppermem(u.ccb.cb, u.ccb.is_set);
468 ret = do_set_cb_virt(u.ccb.cb, u.ccb.is_set, u.ccb.addr, u.ccb.size);
470 case WARMC_VIRT2PHYS:
471 if (copy_from_user(&u.addr, arg, sizeof(u.addr)))
473 ret = do_virt2phys(&u.addr);
474 if (copy_to_user(arg, &u.addr, sizeof(u.addr)))
478 if (copy_from_user(&u.mop, arg, sizeof(u.mop)))
480 if (u.mop.cb & ~(WCB_C_BIT|WCB_B_BIT))
482 ret = do_map_op(u.mop.virt_addr, u.mop.phys_addr, u.mop.size,
483 u.mop.cb, u.mop.is_unmap);
493 static const char *warm_implementor_name(char code)
503 return "Motorola - Freescale";
510 static const char *warm_arch_name(int code)
531 static int warm_cache_size(int code, int m)
539 static int warm_cache_assoc(int code, int m)
546 return base << (code - 1);
549 static int warm_cache_line(int code)
554 static int warm_seq_show(struct seq_file *seq, void *offset)
558 seq_printf(seq, "wARM: " WARM_VER "\n");
561 asm ("mrc p15, 0, %0, c0, c0, 0" : "=r"(tmp));
562 seq_printf(seq, "ID: %08x\n", tmp);
564 /* revised format, not yet documented */
565 } else if ((tmp & 0xf000) == 0) {
567 seq_printf(seq, "Architecture: %d\n",
568 (tmp & 0xf00) == 0x600 ? 3 : 2);
569 seq_printf(seq, "Variant: %d%d0\n", (tmp & 0xf00) >> 8,
572 seq_printf(seq, "Implementor: %c (%s)\n", tmp >> 24,
573 warm_implementor_name(tmp >> 24));
574 if ((tmp & 0xf000) == 7) {
575 seq_printf(seq, "Architecture: %s\n",
576 tmp & 0x800000 ? "4T" : "3");
577 seq_printf(seq, "Variant: 0x%x\n", (tmp & 0x7f0000) >> 16);
579 seq_printf(seq, "Architecture: %s\n",
580 warm_arch_name((tmp & 0x0f0000) >> 16));
581 seq_printf(seq, "Variant: 0x%x\n", (tmp & 0xf00000) >> 20);
583 seq_printf(seq, "Part number: 0x%x\n", (tmp & 0xfff0) >> 4);
585 seq_printf(seq, "Revision: 0x%x\n", tmp & 0xf);
588 asm ("mrc p15, 0, %0, c0, c0, 1" : "=r"(tmp));
589 seq_printf(seq, "Cache ctype: 0x%x\n", (tmp & 0x1e000000) >> 25);
590 seq_printf(seq, "Cache unified: %s\n", (tmp & 0x01000000) ? "no" : "yes");
591 seq_printf(seq, "DCache size: %d\n",
592 warm_cache_size((tmp >> (6+12)) & 0xf, (tmp >> (2+12)) & 1));
593 seq_printf(seq, "DCache associativity: %d\n",
594 warm_cache_assoc((tmp >> (3+12)) & 7, (tmp >> (2+12)) & 1));
595 seq_printf(seq, "DCache line size: %d\n",
596 warm_cache_line((tmp >> (0+12)) & 3));
597 seq_printf(seq, "ICache size: %d\n",
598 warm_cache_size((tmp >> 6) & 0xf, (tmp >> 2) & 1));
599 seq_printf(seq, "ICache associativity: %d\n",
600 warm_cache_assoc((tmp >> 3) & 7, (tmp >> 2) & 1));
601 seq_printf(seq, "ICache line size: %d\n",
602 warm_cache_line((tmp >> 0) & 3));
607 static int warm_open(struct inode *inode, struct file *file)
609 return single_open(file, warm_seq_show, NULL);
612 static int warm_close(struct inode *ino, struct file *file)
614 return single_release(ino, file);
617 static const struct file_operations warm_fops = {
618 .owner = THIS_MODULE,
622 .unlocked_ioctl = warm_ioctl,
623 .release = warm_close,
626 static int __init warm_module_init(void)
628 struct proc_dir_entry *pret;
631 asm ("mrc p15, 0, %0, c0, c0, 0" : "=r"(cpuid));
632 if ((cpuid & 0x0ffff0) != EXPECTED_ID) {
633 printk(KERN_ERR PFX "module was compiled for different CPU, aborting\n");
637 pret = create_proc_entry("warm", S_IWUGO | S_IRUGO, NULL);
639 printk(KERN_ERR PFX "can't create proc entry\n");
643 pret->owner = THIS_MODULE;
644 pret->proc_fops = &warm_fops;
646 spin_lock_init(&lock);
648 uppermem_start = RAM_PHYS_START + (max_mapnr << PAGE_SHIFT);
649 uppermem_end = RAM_PHYS_START + RAM_MAX_SIZE;
651 pr_info(PFX WARM_VER " loaded, ");
652 if (uppermem_end <= uppermem_start)
653 printk("no upper mem");
655 printk("upper mem %08x-%08x", uppermem_start, uppermem_end - 1);
658 /* give time for /proc node to appear */
664 static void __exit warm_module_exit(void)
666 remove_proc_entry("warm", NULL);
668 pr_info(PFX "unloaded.\n");
671 module_init(warm_module_init);
672 module_exit(warm_module_exit);
674 module_param(verbose, int, 0644);
676 MODULE_LICENSE("GPL");
677 MODULE_DESCRIPTION("ARM processor services");
678 MODULE_AUTHOR("Grazvydas Ignotas");