/arch/um/drivers/mmapper_kern.c

https://bitbucket.org/evzijst/gittest · C · 150 lines · 103 code · 27 blank · 20 comment · 12 complexity · 2d5f17beab1b9d4abd5d73c41cd9d81b MD5 · raw file 

    

  1. /*
    2. 

  2.  * arch/um/drivers/mmapper_kern.c
    3. 

  3.  *
    4. 

  4.  * BRIEF MODULE DESCRIPTION
    5. 

  5.  *
    6. 

  6.  * Copyright (C) 2000 RidgeRun, Inc.
    7. 

  7.  * Author: RidgeRun, Inc.
    8. 

  8.  *         Greg Lonnon glonnon@ridgerun.com or info@ridgerun.com
    9. 

  9.  *
    10. 

  10.  */
    11. 

  11. 

  12. #include <linux/types.h>
    13. 

  13. #include <linux/kdev_t.h>
    14. 

  14. #include <linux/time.h>
    15. 

  15. #include <linux/devfs_fs_kernel.h>
    16. 

  16. #include <linux/module.h>
    17. 

  17. #include <linux/mm.h> 
    18. 

  18. #include <linux/slab.h>
    19. 

  19. #include <linux/init.h> 
    20. 

  20. #include <linux/smp_lock.h>
    21. 

  21. #include <asm/uaccess.h>
    22. 

  22. #include <asm/irq.h>
    23. 

  23. #include <asm/pgtable.h>
    24. 

  24. #include "mem_user.h"
    25. 

  25. #include "user_util.h"
    26. 

  26.  
    27. 

  27. /* These are set in mmapper_init, which is called at boot time */
    28. 

  28. static unsigned long mmapper_size;
    29. 

  29. static unsigned long p_buf = 0;
    30. 

  30. static char *v_buf = NULL;
    31. 

  31. 

  32. static ssize_t
    33. 

  33. mmapper_read(struct file *file, char *buf, size_t count, loff_t *ppos)
    34. 

  34. {
    35. 

  35. 	if(*ppos > mmapper_size)
    36. 

  36. 		return -EINVAL;
    37. 

  37. 

  38. 	if(count + *ppos > mmapper_size)
    39. 

  39. 		count = count + *ppos - mmapper_size;
    40. 

  40. 

  41. 	if(count < 0)
    42. 

  42. 		return -EINVAL;
    43. 

  43.  
    44. 

  44. 	copy_to_user(buf,&v_buf[*ppos],count);
    45. 

  45. 	
    46. 

  46. 	return count;
    47. 

  47. }
    48. 

  48. 

  49. static ssize_t
    50. 

  50. mmapper_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
    51. 

  51. {
    52. 

  52. 	if(*ppos > mmapper_size)
    53. 

  53. 		return -EINVAL;
    54. 

  54. 

  55. 	if(count + *ppos > mmapper_size)
    56. 

  56. 		count = count + *ppos - mmapper_size;
    57. 

  57. 

  58. 	if(count < 0)
    59. 

  59. 		return -EINVAL;
    60. 

  60. 

  61. 	copy_from_user(&v_buf[*ppos],buf,count);
    62. 

  62. 	
    63. 

  63. 	return count;
    64. 

  64. }
    65. 

  65. 

  66. static int 
    67. 

  67. mmapper_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
    68. 

  68. 	 unsigned long arg)
    69. 

  69. {
    70. 

  70. 	return(-ENOIOCTLCMD);
    71. 

  71. }
    72. 

  72. 

  73. static int 
    74. 

  74. mmapper_mmap(struct file *file, struct vm_area_struct * vma)
    75. 

  75. {
    76. 

  76. 	int ret = -EINVAL;
    77. 

  77. 	int size;
    78. 

  78. 

  79. 	lock_kernel();
    80. 

  80. 	if (vma->vm_pgoff != 0)
    81. 

  81. 		goto out;
    82. 

  82. 	
    83. 

  83. 	size = vma->vm_end - vma->vm_start;
    84. 

  84. 	if(size > mmapper_size) return(-EFAULT);
    85. 

  85. 

  86. 	/* XXX A comment above remap_pfn_range says it should only be
    87. 

  87. 	 * called when the mm semaphore is held
    88. 

  88. 	 */
    89. 

  89. 	if (remap_pfn_range(vma, vma->vm_start, p_buf >> PAGE_SHIFT, size,
    90. 

  90. 			     vma->vm_page_prot))
    91. 

  91. 		goto out;
    92. 

  92. 	ret = 0;
    93. 

  93. out:
    94. 

  94. 	unlock_kernel();
    95. 

  95. 	return ret;
    96. 

  96. }
    97. 

  97. 

  98. static int
    99. 

  99. mmapper_open(struct inode *inode, struct file *file)
    100. 

  100. {
    101. 

  101. 	return 0;
    102. 

  102. }
    103. 

  103. 

  104. static int 
    105. 

  105. mmapper_release(struct inode *inode, struct file *file)
    106. 

  106. {
    107. 

  107. 	return 0;
    108. 

  108. }
    109. 

  109. 

  110. static struct file_operations mmapper_fops = {
    111. 

  111. 	.owner		= THIS_MODULE,
    112. 

  112. 	.read		= mmapper_read,
    113. 

  113. 	.write		= mmapper_write,
    114. 

  114. 	.ioctl		= mmapper_ioctl,
    115. 

  115. 	.mmap		= mmapper_mmap,
    116. 

  116. 	.open		= mmapper_open,
    117. 

  117. 	.release	= mmapper_release,
    118. 

  118. };
    119. 

  119. 

  120. static int __init mmapper_init(void)
    121. 

  121. {
    122. 

  122. 	printk(KERN_INFO "Mapper v0.1\n");
    123. 

  123. 

  124. 	v_buf = (char *) find_iomem("mmapper", &mmapper_size);
    125. 

  125. 	if(mmapper_size == 0){
    126. 

  126. 		printk(KERN_ERR "mmapper_init - find_iomem failed\n");
    127. 

  127. 		return(0);
    128. 

  128. 	}
    129. 

  129. 

  130. 	p_buf = __pa(v_buf);
    131. 

  131. 

  132. 	devfs_mk_cdev(MKDEV(30, 0), S_IFCHR|S_IRUGO|S_IWUGO, "mmapper");
    133. 

  133. 	return(0);
    134. 

  134. }
    135. 

  135. 

  136. static void mmapper_exit(void)
    137. 

  137. {
    138. 

  138. }
    139. 

  139. 

  140. module_init(mmapper_init);
    141. 

  141. module_exit(mmapper_exit);
    142. 

  142. 

  143. MODULE_AUTHOR("Greg Lonnon <glonnon@ridgerun.com>");
    144. 

  144. MODULE_DESCRIPTION("DSPLinux simulator mmapper driver");
    145. 

  145. /*
    146. 

  146.  * ---------------------------------------------------------------------------
    147. 

  147.  * Local variables:
    148. 

  148.  * c-file-style: "linux"
    149. 

  149.  * End:
    150. 

  150.  */
    151.