Linux-2.6.12-rc2
[linux-2.6.git] / arch / sh / kernel / cpu / sh4 / sq.c
1 /*
2  * arch/sh/kernel/cpu/sq.c
3  *
4  * General management API for SH-4 integrated Store Queues
5  *
6  * Copyright (C) 2001, 2002, 2003, 2004  Paul Mundt
7  * Copyright (C) 2001, 2002  M. R. Brown
8  *
9  * Some of this code has been adopted directly from the old arch/sh/mm/sq.c
10  * hack that was part of the LinuxDC project. For all intents and purposes,
11  * this is a completely new interface that really doesn't have much in common
12  * with the old zone-based approach at all. In fact, it's only listed here for
13  * general completeness.
14  *
15  * This file is subject to the terms and conditions of the GNU General Public
16  * License.  See the file "COPYING" in the main directory of this archive
17  * for more details.
18  */
19 #include <linux/init.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/config.h>
23 #include <linux/slab.h>
24 #include <linux/list.h>
25 #include <linux/proc_fs.h>
26 #include <linux/miscdevice.h>
27 #include <linux/vmalloc.h>
28
29 #include <asm/io.h>
30 #include <asm/page.h>
31 #include <asm/mmu_context.h>
32 #include <asm/cpu/sq.h>
33
34 static LIST_HEAD(sq_mapping_list);
35 static DEFINE_SPINLOCK(sq_mapping_lock);
36
37 /**
38  * sq_flush - Flush (prefetch) the store queue cache
39  * @addr: the store queue address to flush
40  *
41  * Executes a prefetch instruction on the specified store queue cache,
42  * so that the cached data is written to physical memory.
43  */
44 inline void sq_flush(void *addr)
45 {
46         __asm__ __volatile__ ("pref @%0" : : "r" (addr) : "memory");
47 }
48
49 /**
50  * sq_flush_range - Flush (prefetch) a specific SQ range
51  * @start: the store queue address to start flushing from
52  * @len: the length to flush
53  *
54  * Flushes the store queue cache from @start to @start + @len in a
55  * linear fashion.
56  */
57 void sq_flush_range(unsigned long start, unsigned int len)
58 {
59         volatile unsigned long *sq = (unsigned long *)start;
60         unsigned long dummy;
61
62         /* Flush the queues */
63         for (len >>= 5; len--; sq += 8)
64                 sq_flush((void *)sq);
65
66         /* Wait for completion */
67         dummy = ctrl_inl(P4SEG_STORE_QUE);
68
69         ctrl_outl(0, P4SEG_STORE_QUE + 0);
70         ctrl_outl(0, P4SEG_STORE_QUE + 8);
71 }
72
73 static struct sq_mapping *__sq_alloc_mapping(unsigned long virt, unsigned long phys, unsigned long size, const char *name)
74 {
75         struct sq_mapping *map;
76
77         if (virt + size > SQ_ADDRMAX)
78                 return ERR_PTR(-ENOSPC);
79
80         map = kmalloc(sizeof(struct sq_mapping), GFP_KERNEL);
81         if (!map)
82                 return ERR_PTR(-ENOMEM);
83
84         INIT_LIST_HEAD(&map->list);
85
86         map->sq_addr    = virt;
87         map->addr       = phys;
88         map->size       = size + 1;
89         map->name       = name;
90
91         list_add(&map->list, &sq_mapping_list);
92
93         return map;
94 }
95
96 static unsigned long __sq_get_next_addr(void)
97 {
98         if (!list_empty(&sq_mapping_list)) {
99                 struct list_head *pos, *tmp;
100
101                 /*
102                  * Read one off the list head, as it will have the highest
103                  * mapped allocation. Set the next one up right above it.
104                  *
105                  * This is somewhat sub-optimal, as we don't look at
106                  * gaps between allocations or anything lower then the
107                  * highest-level allocation.
108                  *
109                  * However, in the interest of performance and the general
110                  * lack of desire to do constant list rebalancing, we don't
111                  * worry about it.
112                  */
113                 list_for_each_safe(pos, tmp, &sq_mapping_list) {
114                         struct sq_mapping *entry;
115
116                         entry = list_entry(pos, typeof(*entry), list);
117
118                         return entry->sq_addr + entry->size;
119                 }
120         }
121
122         return P4SEG_STORE_QUE;
123 }
124
125 /**
126  * __sq_remap - Perform a translation from the SQ to a phys addr
127  * @map: sq mapping containing phys and store queue addresses.
128  *
129  * Maps the store queue address specified in the mapping to the physical
130  * address specified in the mapping.
131  */
132 static struct sq_mapping *__sq_remap(struct sq_mapping *map)
133 {
134         unsigned long flags, pteh, ptel;
135         struct vm_struct *vma;
136         pgprot_t pgprot;
137
138         /*
139          * Without an MMU (or with it turned off), this is much more
140          * straightforward, as we can just load up each queue's QACR with
141          * the physical address appropriately masked.
142          */
143
144         ctrl_outl(((map->addr >> 26) << 2) & 0x1c, SQ_QACR0);
145         ctrl_outl(((map->addr >> 26) << 2) & 0x1c, SQ_QACR1);
146
147 #ifdef CONFIG_MMU
148         /*
149          * With an MMU on the other hand, things are slightly more involved.
150          * Namely, we have to have a direct mapping between the SQ addr and
151          * the associated physical address in the UTLB by way of setting up
152          * a virt<->phys translation by hand. We do this by simply specifying
153          * the SQ addr in UTLB.VPN and the associated physical address in
154          * UTLB.PPN.
155          *
156          * Notably, even though this is a special case translation, and some
157          * of the configuration bits are meaningless, we're still required
158          * to have a valid ASID context in PTEH.
159          *
160          * We could also probably get by without explicitly setting PTEA, but
161          * we do it here just for good measure.
162          */
163         spin_lock_irqsave(&sq_mapping_lock, flags);
164
165         pteh = map->sq_addr;
166         ctrl_outl((pteh & MMU_VPN_MASK) | get_asid(), MMU_PTEH);
167
168         ptel = map->addr & PAGE_MASK;
169         ctrl_outl(((ptel >> 28) & 0xe) | (ptel & 0x1), MMU_PTEA);
170
171         pgprot = pgprot_noncached(PAGE_KERNEL);
172
173         ptel &= _PAGE_FLAGS_HARDWARE_MASK;
174         ptel |= pgprot_val(pgprot);
175         ctrl_outl(ptel, MMU_PTEL);
176
177         __asm__ __volatile__ ("ldtlb" : : : "memory");
178
179         spin_unlock_irqrestore(&sq_mapping_lock, flags);
180
181         /*
182          * Next, we need to map ourselves in the kernel page table, so that
183          * future accesses after a TLB flush will be handled when we take a
184          * page fault.
185          *
186          * Theoretically we could just do this directly and not worry about
187          * setting up the translation by hand ahead of time, but for the
188          * cases where we want a one-shot SQ mapping followed by a quick
189          * writeout before we hit the TLB flush, we do it anyways. This way
190          * we at least save ourselves the initial page fault overhead.
191          */
192         vma = __get_vm_area(map->size, VM_ALLOC, map->sq_addr, SQ_ADDRMAX);
193         if (!vma)
194                 return ERR_PTR(-ENOMEM);
195
196         vma->phys_addr = map->addr;
197
198         if (remap_area_pages((unsigned long)vma->addr, vma->phys_addr,
199                              map->size, pgprot_val(pgprot))) {
200                 vunmap(vma->addr);
201                 return NULL;
202         }
203 #endif /* CONFIG_MMU */
204
205         return map;
206 }
207
208 /**
209  * sq_remap - Map a physical address through the Store Queues
210  * @phys: Physical address of mapping.
211  * @size: Length of mapping.
212  * @name: User invoking mapping.
213  *
214  * Remaps the physical address @phys through the next available store queue
215  * address of @size length. @name is logged at boot time as well as through
216  * the procfs interface.
217  *
218  * A pre-allocated and filled sq_mapping pointer is returned, and must be
219  * cleaned up with a call to sq_unmap() when the user is done with the
220  * mapping.
221  */
222 struct sq_mapping *sq_remap(unsigned long phys, unsigned int size, const char *name)
223 {
224         struct sq_mapping *map;
225         unsigned long virt, end;
226         unsigned int psz;
227
228         /* Don't allow wraparound or zero size */
229         end = phys + size - 1;
230         if (!size || end < phys)
231                 return NULL;
232         /* Don't allow anyone to remap normal memory.. */
233         if (phys < virt_to_phys(high_memory))
234                 return NULL;
235
236         phys &= PAGE_MASK;
237
238         size  = PAGE_ALIGN(end + 1) - phys;
239         virt  = __sq_get_next_addr();
240         psz   = (size + (PAGE_SIZE - 1)) / PAGE_SIZE;
241         map   = __sq_alloc_mapping(virt, phys, size, name);
242
243         printk("sqremap: %15s  [%4d page%s]  va 0x%08lx   pa 0x%08lx\n",
244                map->name ? map->name : "???",
245                psz, psz == 1 ? " " : "s",
246                map->sq_addr, map->addr);
247
248         return __sq_remap(map);
249 }
250
251 /**
252  * sq_unmap - Unmap a Store Queue allocation
253  * @map: Pre-allocated Store Queue mapping.
254  *
255  * Unmaps the store queue allocation @map that was previously created by
256  * sq_remap(). Also frees up the pte that was previously inserted into
257  * the kernel page table and discards the UTLB translation.
258  */
259 void sq_unmap(struct sq_mapping *map)
260 {
261         if (map->sq_addr > (unsigned long)high_memory)
262                 vfree((void *)(map->sq_addr & PAGE_MASK));
263
264         list_del(&map->list);
265         kfree(map);
266 }
267
268 /**
269  * sq_clear - Clear a store queue range
270  * @addr: Address to start clearing from.
271  * @len: Length to clear.
272  *
273  * A quick zero-fill implementation for clearing out memory that has been
274  * remapped through the store queues.
275  */
276 void sq_clear(unsigned long addr, unsigned int len)
277 {
278         int i;
279
280         /* Clear out both queues linearly */
281         for (i = 0; i < 8; i++) {
282                 ctrl_outl(0, addr + i + 0);
283                 ctrl_outl(0, addr + i + 8);
284         }
285
286         sq_flush_range(addr, len);
287 }
288
289 /**
290  * sq_vma_unmap - Unmap a VMA range
291  * @area: VMA containing range.
292  * @addr: Start of range.
293  * @len: Length of range.
294  *
295  * Searches the sq_mapping_list for a mapping matching the sq addr @addr,
296  * and subsequently frees up the entry. Further cleanup is done by generic
297  * code.
298  */
299 static void sq_vma_unmap(struct vm_area_struct *area,
300                          unsigned long addr, size_t len)
301 {
302         struct list_head *pos, *tmp;
303
304         list_for_each_safe(pos, tmp, &sq_mapping_list) {
305                 struct sq_mapping *entry;
306
307                 entry = list_entry(pos, typeof(*entry), list);
308
309                 if (entry->sq_addr == addr) {
310                         /*
311                          * We could probably get away without doing the tlb flush
312                          * here, as generic code should take care of most of this
313                          * when unmapping the rest of the VMA range for us. Leave
314                          * it in for added sanity for the time being..
315                          */
316                         __flush_tlb_page(get_asid(), entry->sq_addr & PAGE_MASK);
317
318                         list_del(&entry->list);
319                         kfree(entry);
320
321                         return;
322                 }
323         }
324 }
325
326 /**
327  * sq_vma_sync - Sync a VMA range
328  * @area: VMA containing range.
329  * @start: Start of range.
330  * @len: Length of range.
331  * @flags: Additional flags.
332  *
333  * Synchronizes an sq mapped range by flushing the store queue cache for
334  * the duration of the mapping.
335  *
336  * Used internally for user mappings, which must use msync() to prefetch
337  * the store queue cache.
338  */
339 static int sq_vma_sync(struct vm_area_struct *area,
340                        unsigned long start, size_t len, unsigned int flags)
341 {
342         sq_flush_range(start, len);
343
344         return 0;
345 }
346
347 static struct vm_operations_struct sq_vma_ops = {
348         .unmap  = sq_vma_unmap,
349         .sync   = sq_vma_sync,
350 };
351
352 /**
353  * sq_mmap - mmap() for /dev/cpu/sq
354  * @file: unused.
355  * @vma: VMA to remap.
356  *
357  * Remap the specified vma @vma through the store queues, and setup associated
358  * information for the new mapping. Also build up the page tables for the new
359  * area.
360  */
361 static int sq_mmap(struct file *file, struct vm_area_struct *vma)
362 {
363         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
364         unsigned long size = vma->vm_end - vma->vm_start;
365         struct sq_mapping *map;
366
367         /*
368          * We're not interested in any arbitrary virtual address that has
369          * been stuck in the VMA, as we already know what addresses we
370          * want. Save off the size, and reposition the VMA to begin at
371          * the next available sq address.
372          */
373         vma->vm_start = __sq_get_next_addr();
374         vma->vm_end   = vma->vm_start + size;
375
376         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
377
378         vma->vm_flags |= VM_IO | VM_RESERVED;
379
380         map = __sq_alloc_mapping(vma->vm_start, offset, size, "Userspace");
381
382         if (io_remap_pfn_range(vma, map->sq_addr, map->addr >> PAGE_SHIFT,
383                                 size, vma->vm_page_prot))
384                 return -EAGAIN;
385
386         vma->vm_ops = &sq_vma_ops;
387
388         return 0;
389 }
390
391 #ifdef CONFIG_PROC_FS
392 static int sq_mapping_read_proc(char *buf, char **start, off_t off,
393                                 int len, int *eof, void *data)
394 {
395         struct list_head *pos;
396         char *p = buf;
397
398         list_for_each_prev(pos, &sq_mapping_list) {
399                 struct sq_mapping *entry;
400
401                 entry = list_entry(pos, typeof(*entry), list);
402
403                 p += sprintf(p, "%08lx-%08lx [%08lx]: %s\n", entry->sq_addr,
404                              entry->sq_addr + entry->size - 1, entry->addr,
405                              entry->name);
406         }
407
408         return p - buf;
409 }
410 #endif
411
412 static struct file_operations sq_fops = {
413         .owner          = THIS_MODULE,
414         .mmap           = sq_mmap,
415 };
416
417 static struct miscdevice sq_dev = {
418         .minor          = STORE_QUEUE_MINOR,
419         .name           = "sq",
420         .devfs_name     = "cpu/sq",
421         .fops           = &sq_fops,
422 };
423
424 static int __init sq_api_init(void)
425 {
426         printk(KERN_NOTICE "sq: Registering store queue API.\n");
427
428 #ifdef CONFIG_PROC_FS
429         create_proc_read_entry("sq_mapping", 0, 0, sq_mapping_read_proc, 0);
430 #endif
431
432         return misc_register(&sq_dev);
433 }
434
435 static void __exit sq_api_exit(void)
436 {
437         misc_deregister(&sq_dev);
438 }
439
440 module_init(sq_api_init);
441 module_exit(sq_api_exit);
442
443 MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>, M. R. Brown <mrbrown@0xd6.org>");
444 MODULE_DESCRIPTION("Simple API for SH-4 integrated Store Queues");
445 MODULE_LICENSE("GPL");
446 MODULE_ALIAS_MISCDEV(STORE_QUEUE_MINOR);
447
448 EXPORT_SYMBOL(sq_remap);
449 EXPORT_SYMBOL(sq_unmap);
450 EXPORT_SYMBOL(sq_clear);
451 EXPORT_SYMBOL(sq_flush);
452 EXPORT_SYMBOL(sq_flush_range);
453