2 * This confidential and proprietary software may be used only as
3 * authorised by a licensing agreement from ARM Limited
4 * (C) COPYRIGHT 2008-2013 ARM Limited
6 * The entire notice above must be reproduced on all authorised
7 * copies and copies may only be made to the extent permitted
8 * by a licensing agreement from ARM Limited.
11 #include <linux/module.h> /* kernel module definitions */
12 #include <linux/fs.h> /* file system operations */
13 #include <linux/cdev.h> /* character device definitions */
14 #include <linux/ioport.h> /* request_mem_region */
15 #include <linux/mm.h> /* memory management functions and types */
16 #include <asm/uaccess.h> /* user space access */
17 #include <asm/atomic.h>
18 #include <linux/device.h>
19 #include <linux/debugfs.h>
21 #include "arch/config.h" /* Configuration for current platform. The symlinc for arch is set by Makefile */
22 #include "ump_ioctl.h"
23 #include "ump_kernel_common.h"
24 #include "ump_kernel_interface.h"
25 #include "ump_kernel_interface_ref_drv.h"
26 #include "ump_kernel_descriptor_mapping.h"
27 #include "ump_kernel_memory_backend.h"
28 #include "ump_kernel_memory_backend_os.h"
29 #include "ump_kernel_memory_backend_dedicated.h"
30 #include "ump_kernel_license.h"
34 #include "ump_uk_types.h"
35 #include "ump_ukk_wrappers.h"
36 #include "ump_ukk_ref_wrappers.h"
39 /* Module parameter to control log level */
40 int ump_debug_level
= 2;
41 module_param(ump_debug_level
, int, S_IRUSR
| S_IWUSR
| S_IWGRP
| S_IRGRP
| S_IROTH
); /* rw-rw-r-- */
42 MODULE_PARM_DESC(ump_debug_level
, "Higher number, more dmesg output");
44 /* By default the module uses any available major, but it's possible to set it at load time to a specific number */
46 module_param(ump_major
, int, S_IRUGO
); /* r--r--r-- */
47 MODULE_PARM_DESC(ump_major
, "Device major number");
49 /* Name of the UMP device driver */
50 static char ump_dev_name
[] = "ump"; /* should be const, but the functions we call requires non-cost */
53 #if UMP_LICENSE_IS_GPL
54 static struct dentry
*ump_debugfs_dir
= NULL
;
58 * The data which we attached to each virtual memory mapping request we get.
59 * Each memory mapping has a reference to the UMP memory it maps.
60 * We release this reference when the last memory mapping is unmapped.
62 typedef struct ump_vma_usage_tracker
{
65 } ump_vma_usage_tracker
;
69 #if UMP_LICENSE_IS_GPL
70 struct class * ump_class
;
74 /* The global variable containing the global device data */
75 static struct ump_device ump_device
;
78 /* Forward declare static functions */
79 static int ump_file_open(struct inode
*inode
, struct file
*filp
);
80 static int ump_file_release(struct inode
*inode
, struct file
*filp
);
81 #ifdef HAVE_UNLOCKED_IOCTL
82 static long ump_file_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
);
84 static int ump_file_ioctl(struct inode
*inode
, struct file
*filp
, unsigned int cmd
, unsigned long arg
);
86 static int ump_file_mmap(struct file
* filp
, struct vm_area_struct
* vma
);
89 /* This variable defines the file operations this UMP device driver offer */
90 static struct file_operations ump_fops
= {
92 .open
= ump_file_open
,
93 .release
= ump_file_release
,
94 #ifdef HAVE_UNLOCKED_IOCTL
95 .unlocked_ioctl
= ump_file_ioctl
,
97 .ioctl
= ump_file_ioctl
,
103 /* This function is called by Linux to initialize this module.
104 * All we do is initialize the UMP device driver.
106 static int ump_initialize_module(void)
108 _mali_osk_errcode_t err
;
110 DBG_MSG(2, ("Inserting UMP device driver. Compiled: %s, time: %s\n", __DATE__
, __TIME__
));
112 err
= ump_kernel_constructor();
113 if (_MALI_OSK_ERR_OK
!= err
) {
114 MSG_ERR(("UMP device driver init failed\n"));
115 return map_errcode(err
);
118 MSG(("UMP device driver %s loaded\n", SVN_REV_STRING
));
125 * This function is called by Linux to unload/terminate/exit/cleanup this module.
126 * All we do is terminate the UMP device driver.
128 static void ump_cleanup_module(void)
130 DBG_MSG(2, ("Unloading UMP device driver\n"));
131 ump_kernel_destructor();
132 DBG_MSG(2, ("Module unloaded\n"));
137 static ssize_t
ump_memory_used_read(struct file
*filp
, char __user
*ubuf
, size_t cnt
, loff_t
*ppos
)
141 u32 mem
= _ump_ukk_report_memory_usage();
143 r
= snprintf(buf
, 64, "%u\n", mem
);
144 return simple_read_from_buffer(ubuf
, cnt
, ppos
, buf
, r
);
147 static const struct file_operations ump_memory_usage_fops
= {
148 .owner
= THIS_MODULE
,
149 .read
= ump_memory_used_read
,
153 * Initialize the UMP device driver.
155 int ump_kernel_device_initialize(void)
159 #if UMP_LICENSE_IS_GPL
160 ump_debugfs_dir
= debugfs_create_dir(ump_dev_name
, NULL
);
161 if (ERR_PTR(-ENODEV
) == ump_debugfs_dir
) {
162 ump_debugfs_dir
= NULL
;
164 debugfs_create_file("memory_usage", 0400, ump_debugfs_dir
, NULL
, &ump_memory_usage_fops
);
168 if (0 == ump_major
) {
169 /* auto select a major */
170 err
= alloc_chrdev_region(&dev
, 0, 1, ump_dev_name
);
171 ump_major
= MAJOR(dev
);
173 /* use load time defined major number */
174 dev
= MKDEV(ump_major
, 0);
175 err
= register_chrdev_region(dev
, 1, ump_dev_name
);
179 memset(&ump_device
, 0, sizeof(ump_device
));
181 /* initialize our char dev data */
182 cdev_init(&ump_device
.cdev
, &ump_fops
);
183 ump_device
.cdev
.owner
= THIS_MODULE
;
184 ump_device
.cdev
.ops
= &ump_fops
;
186 /* register char dev with the kernel */
187 err
= cdev_add(&ump_device
.cdev
, dev
, 1/*count*/);
190 #if UMP_LICENSE_IS_GPL
191 ump_device
.ump_class
= class_create(THIS_MODULE
, ump_dev_name
);
192 if (IS_ERR(ump_device
.ump_class
)) {
193 err
= PTR_ERR(ump_device
.ump_class
);
195 struct device
* mdev
;
196 mdev
= device_create(ump_device
.ump_class
, NULL
, dev
, NULL
, ump_dev_name
);
203 cdev_del(&ump_device
.cdev
);
209 unregister_chrdev_region(dev
, 1);
218 * Terminate the UMP device driver
220 void ump_kernel_device_terminate(void)
222 dev_t dev
= MKDEV(ump_major
, 0);
224 #if UMP_LICENSE_IS_GPL
225 device_destroy(ump_device
.ump_class
, dev
);
226 class_destroy(ump_device
.ump_class
);
229 /* unregister char device */
230 cdev_del(&ump_device
.cdev
);
233 unregister_chrdev_region(dev
, 1);
235 #if UMP_LICENSE_IS_GPL
237 debugfs_remove_recursive(ump_debugfs_dir
);
242 * Open a new session. User space has called open() on us.
244 static int ump_file_open(struct inode
*inode
, struct file
*filp
)
246 struct ump_session_data
* session_data
;
247 _mali_osk_errcode_t err
;
249 /* input validation */
250 if (0 != MINOR(inode
->i_rdev
)) {
251 MSG_ERR(("Minor not zero in ump_file_open()\n"));
255 /* Call the OS-Independent UMP Open function */
256 err
= _ump_ukk_open((void**) &session_data
);
257 if( _MALI_OSK_ERR_OK
!= err
) {
258 MSG_ERR(("Ump failed to open a new session\n"));
259 return map_errcode( err
);
262 filp
->private_data
= (void*)session_data
;
265 return 0; /* success */
271 * Close a session. User space has called close() or crashed/terminated.
273 static int ump_file_release(struct inode
*inode
, struct file
*filp
)
275 _mali_osk_errcode_t err
;
277 err
= _ump_ukk_close((void**) &filp
->private_data
);
278 if( _MALI_OSK_ERR_OK
!= err
) {
279 return map_errcode( err
);
282 return 0; /* success */
288 * Handle IOCTL requests.
290 #ifdef HAVE_UNLOCKED_IOCTL
291 static long ump_file_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
293 static int ump_file_ioctl(struct inode
*inode
, struct file
*filp
, unsigned int cmd
, unsigned long arg
)
297 void __user
* argument
;
298 struct ump_session_data
* session_data
;
300 #ifndef HAVE_UNLOCKED_IOCTL
301 (void)inode
; /* inode not used */
304 session_data
= (struct ump_session_data
*)filp
->private_data
;
305 if (NULL
== session_data
) {
306 MSG_ERR(("No session data attached to file object\n"));
310 /* interpret the argument as a user pointer to something */
311 argument
= (void __user
*)arg
;
314 case UMP_IOC_QUERY_API_VERSION
:
315 err
= ump_get_api_version_wrapper((u32 __user
*)argument
, session_data
);
318 case UMP_IOC_ALLOCATE
:
319 err
= ump_allocate_wrapper((u32 __user
*)argument
, session_data
);
322 case UMP_IOC_RELEASE
:
323 err
= ump_release_wrapper((u32 __user
*)argument
, session_data
);
326 case UMP_IOC_SIZE_GET
:
327 err
= ump_size_get_wrapper((u32 __user
*)argument
, session_data
);
331 err
= ump_msync_wrapper((u32 __user
*)argument
, session_data
);
334 case UMP_IOC_CACHE_OPERATIONS_CONTROL
:
335 err
= ump_cache_operations_control_wrapper((u32 __user
*)argument
, session_data
);
338 case UMP_IOC_SWITCH_HW_USAGE
:
339 err
= ump_switch_hw_usage_wrapper((u32 __user
*)argument
, session_data
);
343 err
= ump_lock_wrapper((u32 __user
*)argument
, session_data
);
347 err
= ump_unlock_wrapper((u32 __user
*)argument
, session_data
);
351 DBG_MSG(1, ("No handler for IOCTL. cmd: 0x%08x, arg: 0x%08lx\n", cmd
, arg
));
359 int map_errcode( _mali_osk_errcode_t err
)
362 case _MALI_OSK_ERR_OK
:
364 case _MALI_OSK_ERR_FAULT
:
366 case _MALI_OSK_ERR_INVALID_FUNC
:
368 case _MALI_OSK_ERR_INVALID_ARGS
:
370 case _MALI_OSK_ERR_NOMEM
:
372 case _MALI_OSK_ERR_TIMEOUT
:
374 case _MALI_OSK_ERR_RESTARTSYSCALL
:
376 case _MALI_OSK_ERR_ITEM_NOT_FOUND
:
384 * Handle from OS to map specified virtual memory to specified UMP memory.
386 static int ump_file_mmap(struct file
* filp
, struct vm_area_struct
* vma
)
388 _ump_uk_map_mem_s args
;
389 _mali_osk_errcode_t err
;
390 struct ump_session_data
* session_data
;
392 /* Validate the session data */
393 session_data
= (struct ump_session_data
*)filp
->private_data
;
394 if (NULL
== session_data
) {
395 MSG_ERR(("mmap() called without any session data available\n"));
399 /* Re-pack the arguments that mmap() packed for us */
400 args
.ctx
= session_data
;
402 args
.size
= vma
->vm_end
- vma
->vm_start
;
403 args
._ukk_private
= vma
;
404 args
.secure_id
= vma
->vm_pgoff
;
407 if (!(vma
->vm_flags
& VM_SHARED
)) {
409 vma
->vm_flags
= vma
->vm_flags
| VM_SHARED
| VM_MAYSHARE
;
410 DBG_MSG(3, ("UMP Map function: Forcing the CPU to use cache\n"));
412 /* By setting this flag, during a process fork; the child process will not have the parent UMP mappings */
413 vma
->vm_flags
|= VM_DONTCOPY
;
415 DBG_MSG(4, ("UMP vma->flags: %x\n", vma
->vm_flags
));
417 /* Call the common mmap handler */
418 err
= _ump_ukk_map_mem( &args
);
419 if ( _MALI_OSK_ERR_OK
!= err
) {
420 MSG_ERR(("_ump_ukk_map_mem() failed in function ump_file_mmap()"));
421 return map_errcode( err
);
424 return 0; /* success */
427 /* Export UMP kernel space API functions */
428 EXPORT_SYMBOL(ump_dd_secure_id_get
);
429 EXPORT_SYMBOL(ump_dd_handle_create_from_secure_id
);
430 EXPORT_SYMBOL(ump_dd_phys_block_count_get
);
431 EXPORT_SYMBOL(ump_dd_phys_block_get
);
432 EXPORT_SYMBOL(ump_dd_phys_blocks_get
);
433 EXPORT_SYMBOL(ump_dd_size_get
);
434 EXPORT_SYMBOL(ump_dd_reference_add
);
435 EXPORT_SYMBOL(ump_dd_reference_release
);
437 /* Export our own extended kernel space allocator */
438 EXPORT_SYMBOL(ump_dd_handle_create_from_phys_blocks
);
440 /* Setup init and exit functions for this module */
441 module_init(ump_initialize_module
);
442 module_exit(ump_cleanup_module
);
444 /* And some module informatio */
445 MODULE_LICENSE(UMP_KERNEL_LINUX_LICENSE
);
446 MODULE_AUTHOR("ARM Ltd.");
447 MODULE_VERSION(SVN_REV_STRING
);