crt0mega
/
amifldrv
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix indention and whitespaces

This commit is contained in:
Florian Lohoff 2018-07-24 15:29:28 +02:00
parent 8968ffa2f4
commit ced70a7433
1 changed files with 218 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

447
amifldrv.c
View File

@ -17,11 +17,11 @@
#define LINUX_POST_2_6 (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)) #define LINUX_POST_2_6 (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0))
#if LINUX_PRE_2_6 #if LINUX_PRE_2_6
# include <linux/wrapper.h> #include <linux/wrapper.h>
#else #else
# define mem_map_reserve(p) set_bit (PG_reserved, &((p)->flags)) #define mem_map_reserve(p) set_bit (PG_reserved, &((p)->flags))
# define mem_map_unreserve(p) clear_bit(PG_reserved, &((p)->flags)) #define mem_map_unreserve(p) clear_bit(PG_reserved, &((p)->flags))
#endif #endif
#define CMD_ALLOC 0x4160 #define CMD_ALLOC 0x4160
#define CMD_FREE 0x4161 #define CMD_FREE 0x4161
@ -32,17 +32,17 @@
* ioctl data packet used to communicate instructions to the driver * ioctl data packet used to communicate instructions to the driver
*/ */
typedef struct _struct_AMIFL_alloc_params { typedef struct _struct_AMIFL_alloc_params {
long size; long size;
unsigned long kvirtlen; unsigned long kvirtlen;
void* kmallocptr; void *kmallocptr;
void* kvirtadd; void *kvirtadd;
void* kphysadd; void *kphysadd;
} AMIFL_alloc_params; } AMIFL_alloc_params;
static int *kmalloc_area = NULL; static int *kmalloc_area = NULL;
static int *kmalloc_ptr = NULL; static int *kmalloc_ptr = NULL;
static unsigned long kmalloc_len = 0L; static unsigned long kmalloc_len = 0L;
static int kcount = 0; static int kcount = 0;
static int major; static int major;
static AMIFL_alloc_params kmalloc_drv[128]; static AMIFL_alloc_params kmalloc_drv[128];
@ -53,233 +53,231 @@ static AMIFL_alloc_params kmalloc_drv[128];
#if LINUX_POST_2_6 #if LINUX_POST_2_6
static int chardev_open_count = 0; static int chardev_open_count = 0;
#endif #endif
/** /**
* Character Device open action * Character Device open action
*/ */
int int AMI_chrdrv_open(struct inode *inode, struct file *file)
AMI_chrdrv_open(struct inode* inode, struct file* file)
{ {
#if LINUX_PRE_2_6 #if LINUX_PRE_2_6
MOD_INC_USE_COUNT; MOD_INC_USE_COUNT;
#else #else
if (chardev_open_count > 0) if (chardev_open_count > 0) {
{ return -EBUSY;
return -EBUSY; }
}
++chardev_open_count; ++chardev_open_count;
try_module_get(THIS_MODULE); try_module_get(THIS_MODULE);
#endif #endif
return(0); return (0);
} }
int int AMI_chrdrv_release(struct inode *inode, struct file *file)
AMI_chrdrv_release(struct inode* inode, struct file* file)
{ {
#if LINUX_PRE_2_6 #if LINUX_PRE_2_6
MOD_DEC_USE_COUNT; MOD_DEC_USE_COUNT;
#else #else
--chardev_open_count; --chardev_open_count;
module_put(THIS_MODULE); module_put(THIS_MODULE);
#endif #endif
return(0); return (0);
} }
#if defined(HAVE_UNLOCKED_IOCTL) #if defined(HAVE_UNLOCKED_IOCTL)
long long AMI_chrdrv_ioctl(struct file *_unused_file, unsigned int cmd, unsigned long arg)
AMI_chrdrv_ioctl(struct file* _unused_file, unsigned int cmd, unsigned long arg)
#else #else
int int AMI_chrdrv_ioctl(struct inode *_unused_inode, unsigned int cmd, unsigned long arg)
AMI_chrdrv_ioctl(struct inode* _unused_inode, unsigned int cmd, unsigned long arg) #endif
#endif
{ {
switch(cmd) switch (cmd) {
{ case CMD_ALLOC:
case CMD_ALLOC: {
{ unsigned long virt_addr;
unsigned long virt_addr; AMIFL_alloc_params arg_kernel_space;
AMIFL_alloc_params arg_kernel_space;
if (kcount >= 128) if (kcount >= 128) {
{ return -EINVAL;
return -EINVAL; }
}
kmalloc_ptr = NULL; kmalloc_ptr = NULL;
if (!arg || kmalloc_ptr) if (!arg || kmalloc_ptr) {
{ return -EINVAL;
return -EINVAL; }
}
copy_from_user((void*) &arg_kernel_space, (void*) arg, sizeof(AMIFL_alloc_params)); copy_from_user((void *) &arg_kernel_space, (void *) arg,
sizeof(AMIFL_alloc_params));
if (arg_kernel_space.size > 128 * 1024) if (arg_kernel_space.size > 128 * 1024) {
{ return -EINVAL;
return -EINVAL; }
}
kmalloc_len = ((arg_kernel_space.size + PAGE_SIZE - 1) & PAGE_MASK); kmalloc_len = ((arg_kernel_space.size + PAGE_SIZE - 1) & PAGE_MASK);
kmalloc_ptr = kmalloc((kmalloc_len + 2 * PAGE_SIZE), GFP_DMA | GFP_KERNEL); kmalloc_ptr = kmalloc((kmalloc_len + 2 * PAGE_SIZE), GFP_DMA | GFP_KERNEL);
kmalloc_area = (int *)(((unsigned long)kmalloc_ptr + PAGE_SIZE - 1) & PAGE_MASK); kmalloc_area =
(int *) (((unsigned long) kmalloc_ptr + PAGE_SIZE - 1) & PAGE_MASK);
for (virt_addr = (unsigned long) kmalloc_area; for (virt_addr = (unsigned long) kmalloc_area;
virt_addr < (unsigned long) kmalloc_area + kmalloc_len; virt_addr < (unsigned long) kmalloc_area + kmalloc_len;
virt_addr += PAGE_SIZE) virt_addr += PAGE_SIZE) {
{ mem_map_reserve(virt_to_page(virt_addr));
mem_map_reserve(virt_to_page(virt_addr)); }
}
{ {
int i; int i;
for (i = 0; i < (kmalloc_len / sizeof(int)); ++i) { for (i = 0; i < (kmalloc_len / sizeof(int)); ++i) {
kmalloc_area[i] = 0xAFD00000 + i; kmalloc_area[i] = 0xAFD00000 + i;
} }
} }
kmalloc_drv[kcount].size = arg_kernel_space.size; kmalloc_drv[kcount].size = arg_kernel_space.size;
kmalloc_drv[kcount].kmallocptr = kmalloc_ptr; kmalloc_drv[kcount].kmallocptr = kmalloc_ptr;
kmalloc_drv[kcount].kvirtlen = kmalloc_len; kmalloc_drv[kcount].kvirtlen = kmalloc_len;
kmalloc_drv[kcount].kvirtadd = kmalloc_area; kmalloc_drv[kcount].kvirtadd = kmalloc_area;
kmalloc_drv[kcount].kphysadd = (void *)((unsigned long)virt_to_phys(kmalloc_area)); kmalloc_drv[kcount].kphysadd =
++kcount; (void *) ((unsigned long) virt_to_phys(kmalloc_area));
++kcount;
arg_kernel_space.kvirtadd = kmalloc_area; arg_kernel_space.kvirtadd = kmalloc_area;
arg_kernel_space.kphysadd = (void *)((unsigned long)virt_to_phys(kmalloc_area)); arg_kernel_space.kphysadd =
(void *) ((unsigned long) virt_to_phys(kmalloc_area));
copy_to_user((void*) arg, (void*) &arg_kernel_space, sizeof(AMIFL_alloc_params)); copy_to_user((void *) arg, (void *) &arg_kernel_space,
sizeof(AMIFL_alloc_params));
return 0; return 0;
} }
case CMD_FREE: case CMD_FREE:
{ {
unsigned long virt_addr; unsigned long virt_addr;
AMIFL_alloc_params arg_kernel_space; AMIFL_alloc_params arg_kernel_space;
int isearch = 0; int isearch = 0;
copy_from_user((void*) &arg_kernel_space, (void*) arg, sizeof(AMIFL_alloc_params)); copy_from_user((void *) &arg_kernel_space, (void *) arg,
sizeof(AMIFL_alloc_params));
if (kcount > 0) { if (kcount > 0) {
for (isearch=0; isearch<kcount; isearch++) { for (isearch = 0; isearch < kcount; isearch++) {
if (kmalloc_drv[isearch].kphysadd == arg_kernel_space.kphysadd) break; if (kmalloc_drv[isearch].kphysadd ==
} arg_kernel_space.kphysadd)
if (isearch >= kcount) return 0; break;
kmalloc_ptr = kmalloc_drv[isearch].kmallocptr; }
kmalloc_area = kmalloc_drv[isearch].kvirtadd; if (isearch >= kcount)
kmalloc_len = kmalloc_drv[isearch].kvirtlen; return 0;
} else kmalloc_ptr = kmalloc_drv[isearch].kmallocptr;
return 0; kmalloc_area = kmalloc_drv[isearch].kvirtadd;
if (kmalloc_ptr) { kmalloc_len = kmalloc_drv[isearch].kvirtlen;
for(virt_addr = (unsigned long) kmalloc_area; } else
virt_addr < (unsigned long) kmalloc_area + kmalloc_len; return 0;
virt_addr += PAGE_SIZE) if (kmalloc_ptr) {
{ for (virt_addr = (unsigned long) kmalloc_area;
mem_map_unreserve(virt_to_page(virt_addr)); virt_addr < (unsigned long) kmalloc_area + kmalloc_len;
} virt_addr += PAGE_SIZE) {
mem_map_unreserve(virt_to_page(virt_addr));
}
if (kmalloc_ptr) { if (kmalloc_ptr) {
kfree(kmalloc_ptr); kfree(kmalloc_ptr);
} }
kmalloc_len = 0L; kmalloc_len = 0L;
kmalloc_ptr = NULL; kmalloc_ptr = NULL;
kmalloc_area = NULL; kmalloc_area = NULL;
kcount--; kcount--;
if (isearch != kcount) { if (isearch != kcount) {
kmalloc_drv[isearch].size = kmalloc_drv[kcount].size; kmalloc_drv[isearch].size = kmalloc_drv[kcount].size;
kmalloc_drv[isearch].kmallocptr = kmalloc_drv[kcount].kmallocptr; kmalloc_drv[isearch].kmallocptr =
kmalloc_drv[isearch].kvirtlen = kmalloc_drv[kcount].kvirtlen; kmalloc_drv[kcount].kmallocptr;
kmalloc_drv[isearch].kvirtadd = kmalloc_drv[kcount].kvirtadd; kmalloc_drv[isearch].kvirtlen =
kmalloc_drv[isearch].kphysadd = kmalloc_drv[kcount].kphysadd; kmalloc_drv[kcount].kvirtlen;
} kmalloc_drv[isearch].kvirtadd =
kmalloc_drv[kcount].kvirtadd;
kmalloc_drv[isearch].kphysadd =
kmalloc_drv[kcount].kphysadd;
}
kmalloc_drv[kcount].size = 0; kmalloc_drv[kcount].size = 0;
kmalloc_drv[kcount].kmallocptr = NULL; kmalloc_drv[kcount].kmallocptr = NULL;
kmalloc_drv[kcount].kvirtlen = 0; kmalloc_drv[kcount].kvirtlen = 0;
kmalloc_drv[kcount].kvirtadd = NULL; kmalloc_drv[kcount].kvirtadd = NULL;
kmalloc_drv[kcount].kphysadd = NULL; kmalloc_drv[kcount].kphysadd = NULL;
} }
return 0; return 0;
} }
case CMD_LOCK_KB: case CMD_LOCK_KB:
disable_irq(1); disable_irq(1);
return 0; return 0;
case CMD_UNLOCK_KB: case CMD_UNLOCK_KB:
enable_irq(1); enable_irq(1);
return 0; return 0;
} }
return -ENOTTY; return -ENOTTY;
} }
int int AMI_chrdrv_mmap(struct file *file, struct vm_area_struct *vma)
AMI_chrdrv_mmap(struct file* file, struct vm_area_struct* vma)
{ {
unsigned long offset = vma->vm_pgoff << PAGE_SHIFT; unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
unsigned long size = vma->vm_end - vma->vm_start; unsigned long size = vma->vm_end - vma->vm_start;
if (offset & ~PAGE_MASK) { if (offset & ~PAGE_MASK) {
return -ENXIO; return -ENXIO;
} }
if (!kmalloc_ptr) { if (!kmalloc_ptr) {
return(-ENXIO); return (-ENXIO);
} }
if (size > kmalloc_len) { if (size > kmalloc_len) {
return(-ENXIO); return (-ENXIO);
} }
if ((offset+size) > kmalloc_len) { if ((offset + size) > kmalloc_len) {
return -ENXIO; return -ENXIO;
} }
if ((vma->vm_flags & VM_WRITE) && !(vma->vm_flags & VM_SHARED)) { if ((vma->vm_flags & VM_WRITE) && !(vma->vm_flags & VM_SHARED)) {
return(-EINVAL); return (-EINVAL);
} }
vma->vm_flags |= VM_LOCKED; vma->vm_flags |= VM_LOCKED;
{ {
unsigned long pfn = virt_to_phys((void*)((unsigned long) kmalloc_area)); unsigned long pfn = virt_to_phys((void *) ((unsigned long) kmalloc_area));
#if LINUX_POST_2_6 #if LINUX_POST_2_6
int remap_result = int remap_result = remap_pfn_range(vma,
remap_pfn_range(vma, vma->vm_start,
vma->vm_start, pfn >> PAGE_SHIFT,
pfn >> PAGE_SHIFT, size,
size, PAGE_SHARED);
PAGE_SHARED);
#else #else
int remap_result = int remap_result = remap_page_range(vma,
remap_page_range(vma, vma->vm_start,
vma->vm_start, pfn,
pfn, size,
size, PAGE_SHARED);
PAGE_SHARED);
#endif #endif
if (remap_result) if (remap_result) {
{ return -ENXIO;
return -ENXIO; }
} }
}
return(0); return (0);
} }
#if defined(HAVE_UNLOCKED_IOCTL) #if defined(HAVE_UNLOCKED_IOCTL)
# define $IOCTL_FIELD unlocked_ioctl #define $IOCTL_FIELD unlocked_ioctl
#else #else
# define $IOCTL_FIELD ioctl #define $IOCTL_FIELD ioctl
#endif #endif
struct file_operations AMI_chrdrv_fops = { struct file_operations AMI_chrdrv_fops = {
owner: THIS_MODULE, owner:THIS_MODULE,
open: AMI_chrdrv_open, open:AMI_chrdrv_open,
release: AMI_chrdrv_release, release:AMI_chrdrv_release,
mmap: AMI_chrdrv_mmap, mmap:AMI_chrdrv_mmap,
$IOCTL_FIELD: AMI_chrdrv_ioctl, $IOCTL_FIELD:AMI_chrdrv_ioctl,
}; };
/* /*
@ -289,64 +287,55 @@ struct file_operations AMI_chrdrv_fops = {
#if LINUX_POST_2_6 #if LINUX_POST_2_6
MODULE_AUTHOR ("American Megatrends Inc."); MODULE_AUTHOR("American Megatrends Inc.");
MODULE_DESCRIPTION ("AMI Flash Update utility driver"); MODULE_DESCRIPTION("AMI Flash Update utility driver");
MODULE_LICENSE ("Proprietary"); MODULE_LICENSE("Proprietary");
#endif #endif
static int /* module_init */ static int /* module_init */ amifldrv_init_module(void)
amifldrv_init_module(void)
{ {
major = register_chrdev(0, "amifldrv", &AMI_chrdrv_fops); major = register_chrdev(0, "amifldrv", &AMI_chrdrv_fops);
if (major < 0)
{
return -EIO;
}
memset(kmalloc_drv, 0, sizeof(AMIFL_alloc_params) * 128); if (major < 0) {
return -EIO;
}
return(0); memset(kmalloc_drv, 0, sizeof(AMIFL_alloc_params) * 128);
return (0);
} }
static void /* module_exit */ static void /* module_exit */ amifldrv_cleanup_module(void)
amifldrv_cleanup_module(void)
{ {
unsigned long virt_addr; unsigned long virt_addr;
if (kcount > 0) if (kcount > 0) {
{ {
{ int iloop;
int iloop; for (iloop = 0; iloop < kcount; ++iloop) {
for (iloop = 0; iloop < kcount; ++iloop) kmalloc_ptr = kmalloc_drv[iloop].kmallocptr;
{ kmalloc_area = kmalloc_drv[iloop].kvirtadd;
kmalloc_ptr = kmalloc_drv[iloop].kmallocptr; kmalloc_len = kmalloc_drv[iloop].kvirtlen;
kmalloc_area = kmalloc_drv[iloop].kvirtadd; if (kmalloc_ptr) {
kmalloc_len = kmalloc_drv[iloop].kvirtlen; for (virt_addr = (unsigned long) kmalloc_area;
if (kmalloc_ptr) virt_addr < (unsigned long) kmalloc_area + kmalloc_len;
{ virt_addr += PAGE_SIZE) {
for(virt_addr = (unsigned long)kmalloc_area; mem_map_unreserve(virt_to_page(virt_addr));
virt_addr < (unsigned long)kmalloc_area + kmalloc_len; }
virt_addr += PAGE_SIZE)
{
mem_map_unreserve(virt_to_page(virt_addr));
}
if (kmalloc_ptr) if (kmalloc_ptr) {
{ kfree(kmalloc_ptr);
kfree(kmalloc_ptr); }
} }
} }
} }
} kcount = 0;
kcount = 0; }
}
unregister_chrdev(major, "amifldrv"); unregister_chrdev(major, "amifldrv");
return; return;
} }
module_init(amifldrv_init_module); module_init(amifldrv_init_module);
module_exit(amifldrv_cleanup_module); module_exit(amifldrv_cleanup_module);