2 * arch/sh/kernel/cpu/sh4/sq.c
4 * General management API for SH-4 integrated Store Queues
6 * Copyright (C) 2001 - 2006 Paul Mundt
7 * Copyright (C) 2001, 2002 M. R. Brown
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
13 #include <linux/init.h>
14 #include <linux/cpu.h>
15 #include <linux/bitmap.h>
16 #include <linux/sysdev.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/slab.h>
20 #include <linux/vmalloc.h>
24 #include <asm/cacheflush.h>
25 #include <asm/cpu/sq.h>
32 unsigned long sq_addr
;
36 struct sq_mapping
*next
;
39 static struct sq_mapping
*sq_mapping_list
;
40 static DEFINE_SPINLOCK(sq_mapping_lock
);
41 static struct kmem_cache
*sq_cache
;
42 static unsigned long *sq_bitmap
;
44 #define store_queue_barrier() \
46 (void)ctrl_inl(P4SEG_STORE_QUE); \
47 ctrl_outl(0, P4SEG_STORE_QUE + 0); \
48 ctrl_outl(0, P4SEG_STORE_QUE + 8); \
52 * sq_flush_range - Flush (prefetch) a specific SQ range
53 * @start: the store queue address to start flushing from
54 * @len: the length to flush
56 * Flushes the store queue cache from @start to @start + @len in a
59 void sq_flush_range(unsigned long start
, unsigned int len
)
61 volatile unsigned long *sq
= (unsigned long *)start
;
63 /* Flush the queues */
64 for (len
>>= 5; len
--; sq
+= 8)
65 prefetchw((void *)sq
);
67 /* Wait for completion */
68 store_queue_barrier();
70 EXPORT_SYMBOL(sq_flush_range
);
72 static inline void sq_mapping_list_add(struct sq_mapping
*map
)
74 struct sq_mapping
**p
, *tmp
;
76 spin_lock_irq(&sq_mapping_lock
);
79 while ((tmp
= *p
) != NULL
)
85 spin_unlock_irq(&sq_mapping_lock
);
88 static inline void sq_mapping_list_del(struct sq_mapping
*map
)
90 struct sq_mapping
**p
, *tmp
;
92 spin_lock_irq(&sq_mapping_lock
);
94 for (p
= &sq_mapping_list
; (tmp
= *p
); p
= &tmp
->next
)
100 spin_unlock_irq(&sq_mapping_lock
);
103 static int __sq_remap(struct sq_mapping
*map
, unsigned long flags
)
105 #if defined(CONFIG_MMU)
106 struct vm_struct
*vma
;
108 vma
= __get_vm_area(map
->size
, VM_ALLOC
, map
->sq_addr
, SQ_ADDRMAX
);
112 vma
->phys_addr
= map
->addr
;
114 if (remap_area_pages((unsigned long)vma
->addr
, vma
->phys_addr
,
121 * Without an MMU (or with it turned off), this is much more
122 * straightforward, as we can just load up each queue's QACR with
123 * the physical address appropriately masked.
125 ctrl_outl(((map
->addr
>> 26) << 2) & 0x1c, SQ_QACR0
);
126 ctrl_outl(((map
->addr
>> 26) << 2) & 0x1c, SQ_QACR1
);
133 * sq_remap - Map a physical address through the Store Queues
134 * @phys: Physical address of mapping.
135 * @size: Length of mapping.
136 * @name: User invoking mapping.
137 * @flags: Protection flags.
139 * Remaps the physical address @phys through the next available store queue
140 * address of @size length. @name is logged at boot time as well as through
141 * the sysfs interface.
143 unsigned long sq_remap(unsigned long phys
, unsigned int size
,
144 const char *name
, unsigned long flags
)
146 struct sq_mapping
*map
;
151 /* Don't allow wraparound or zero size */
152 end
= phys
+ size
- 1;
153 if (unlikely(!size
|| end
< phys
))
155 /* Don't allow anyone to remap normal memory.. */
156 if (unlikely(phys
< virt_to_phys(high_memory
)))
160 size
= PAGE_ALIGN(end
+ 1) - phys
;
162 map
= kmem_cache_alloc(sq_cache
, GFP_KERNEL
);
170 page
= bitmap_find_free_region(sq_bitmap
, 0x04000000 >> PAGE_SHIFT
,
171 get_order(map
->size
));
172 if (unlikely(page
< 0)) {
177 map
->sq_addr
= P4SEG_STORE_QUE
+ (page
<< PAGE_SHIFT
);
179 ret
= __sq_remap(map
, flags
);
180 if (unlikely(ret
!= 0))
183 psz
= (size
+ (PAGE_SIZE
- 1)) >> PAGE_SHIFT
;
184 pr_info("sqremap: %15s [%4d page%s] va 0x%08lx pa 0x%08lx\n",
185 likely(map
->name
) ? map
->name
: "???",
186 psz
, psz
== 1 ? " " : "s",
187 map
->sq_addr
, map
->addr
);
189 sq_mapping_list_add(map
);
194 kmem_cache_free(sq_cache
, map
);
197 EXPORT_SYMBOL(sq_remap
);
200 * sq_unmap - Unmap a Store Queue allocation
201 * @map: Pre-allocated Store Queue mapping.
203 * Unmaps the store queue allocation @map that was previously created by
204 * sq_remap(). Also frees up the pte that was previously inserted into
205 * the kernel page table and discards the UTLB translation.
207 void sq_unmap(unsigned long vaddr
)
209 struct sq_mapping
**p
, *map
;
210 struct vm_struct
*vma
;
213 for (p
= &sq_mapping_list
; (map
= *p
); p
= &map
->next
)
214 if (map
->sq_addr
== vaddr
)
217 if (unlikely(!map
)) {
218 printk("%s: bad store queue address 0x%08lx\n",
219 __FUNCTION__
, vaddr
);
223 page
= (map
->sq_addr
- P4SEG_STORE_QUE
) >> PAGE_SHIFT
;
224 bitmap_release_region(sq_bitmap
, page
, get_order(map
->size
));
227 vma
= remove_vm_area((void *)(map
->sq_addr
& PAGE_MASK
));
229 printk(KERN_ERR
"%s: bad address 0x%08lx\n",
230 __FUNCTION__
, map
->sq_addr
);
235 sq_mapping_list_del(map
);
237 kmem_cache_free(sq_cache
, map
);
239 EXPORT_SYMBOL(sq_unmap
);
242 * Needlessly complex sysfs interface. Unfortunately it doesn't seem like
243 * there is any other easy way to add things on a per-cpu basis without
244 * putting the directory entries somewhere stupid and having to create
245 * links in sysfs by hand back in to the per-cpu directories.
247 * Some day we may want to have an additional abstraction per store
248 * queue, but considering the kobject hell we already have to deal with,
249 * it's simply not worth the trouble.
251 static struct kobject
*sq_kobject
[NR_CPUS
];
253 struct sq_sysfs_attr
{
254 struct attribute attr
;
255 ssize_t (*show
)(char *buf
);
256 ssize_t (*store
)(const char *buf
, size_t count
);
259 #define to_sq_sysfs_attr(attr) container_of(attr, struct sq_sysfs_attr, attr)
261 static ssize_t
sq_sysfs_show(struct kobject
*kobj
, struct attribute
*attr
,
264 struct sq_sysfs_attr
*sattr
= to_sq_sysfs_attr(attr
);
266 if (likely(sattr
->show
))
267 return sattr
->show(buf
);
272 static ssize_t
sq_sysfs_store(struct kobject
*kobj
, struct attribute
*attr
,
273 const char *buf
, size_t count
)
275 struct sq_sysfs_attr
*sattr
= to_sq_sysfs_attr(attr
);
277 if (likely(sattr
->store
))
278 return sattr
->store(buf
, count
);
283 static ssize_t
mapping_show(char *buf
)
285 struct sq_mapping
**list
, *entry
;
288 for (list
= &sq_mapping_list
; (entry
= *list
); list
= &entry
->next
)
289 p
+= sprintf(p
, "%08lx-%08lx [%08lx]: %s\n",
290 entry
->sq_addr
, entry
->sq_addr
+ entry
->size
,
291 entry
->addr
, entry
->name
);
296 static ssize_t
mapping_store(const char *buf
, size_t count
)
298 unsigned long base
= 0, len
= 0;
300 sscanf(buf
, "%lx %lx", &base
, &len
);
305 int ret
= sq_remap(base
, len
, "Userspace",
306 pgprot_val(PAGE_SHARED
));
315 static struct sq_sysfs_attr mapping_attr
=
316 __ATTR(mapping
, 0644, mapping_show
, mapping_store
);
318 static struct attribute
*sq_sysfs_attrs
[] = {
323 static struct sysfs_ops sq_sysfs_ops
= {
324 .show
= sq_sysfs_show
,
325 .store
= sq_sysfs_store
,
328 static struct kobj_type ktype_percpu_entry
= {
329 .sysfs_ops
= &sq_sysfs_ops
,
330 .default_attrs
= sq_sysfs_attrs
,
333 static int __devinit
sq_sysdev_add(struct sys_device
*sysdev
)
335 unsigned int cpu
= sysdev
->id
;
336 struct kobject
*kobj
;
338 sq_kobject
[cpu
] = kzalloc(sizeof(struct kobject
), GFP_KERNEL
);
339 if (unlikely(!sq_kobject
[cpu
]))
342 kobj
= sq_kobject
[cpu
];
343 kobj
->parent
= &sysdev
->kobj
;
344 kobject_set_name(kobj
, "%s", "sq");
345 kobj
->ktype
= &ktype_percpu_entry
;
347 return kobject_register(kobj
);
350 static int __devexit
sq_sysdev_remove(struct sys_device
*sysdev
)
352 unsigned int cpu
= sysdev
->id
;
353 struct kobject
*kobj
= sq_kobject
[cpu
];
355 kobject_unregister(kobj
);
359 static struct sysdev_driver sq_sysdev_driver
= {
360 .add
= sq_sysdev_add
,
361 .remove
= __devexit_p(sq_sysdev_remove
),
364 static int __init
sq_api_init(void)
366 unsigned int nr_pages
= 0x04000000 >> PAGE_SHIFT
;
367 unsigned int size
= (nr_pages
+ (BITS_PER_LONG
- 1)) / BITS_PER_LONG
;
370 printk(KERN_NOTICE
"sq: Registering store queue API.\n");
372 sq_cache
= kmem_cache_create("store_queue_cache",
373 sizeof(struct sq_mapping
), 0, 0,
375 if (unlikely(!sq_cache
))
378 sq_bitmap
= kzalloc(size
, GFP_KERNEL
);
379 if (unlikely(!sq_bitmap
))
382 ret
= sysdev_driver_register(&cpu_sysdev_class
, &sq_sysdev_driver
);
383 if (unlikely(ret
!= 0))
390 kmem_cache_destroy(sq_cache
);
395 static void __exit
sq_api_exit(void)
397 sysdev_driver_unregister(&cpu_sysdev_class
, &sq_sysdev_driver
);
399 kmem_cache_destroy(sq_cache
);
402 module_init(sq_api_init
);
403 module_exit(sq_api_exit
);
405 MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>, M. R. Brown <mrbrown@0xd6.org>");
406 MODULE_DESCRIPTION("Simple API for SH-4 integrated Store Queues");
407 MODULE_LICENSE("GPL");