| /* |
| * Copyright (C) 2008-2013, NVIDIA Corporation. All rights reserved. |
| * |
| * Author: |
| * Ashutosh Patel <ashutoshp@nvidia.com> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| * more details. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with this program; if not, write to the Free Software Foundation, Inc., |
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| * |
| * drivers/char/tegra-efshlp.c - EFS filesystem helper |
| * |
| */ |
| #include <linux/module.h> |
| #include <linux/version.h> |
| #include <linux/types.h> |
| #include <linux/errno.h> |
| #include <linux/kernel.h> |
| #include <linux/device.h> |
| #include <linux/sched.h> |
| #include <linux/slab.h> |
| #include <linux/fs.h> |
| #include <linux/cdev.h> |
| #include <linux/uaccess.h> |
| #include <linux/init.h> |
| #include <linux/mm.h> |
| #include <linux/efshlp.h> |
| #include <linux/vmalloc.h> |
| #include <linux/mtd/map.h> |
| #include <linux/tegra_snor.h> |
| #include <linux/platform_data/tegra_nor.h> |
| |
| #define EFSHLP_DEVICE "efshlp" |
| #define EFSHLP_DEVICE_NO 1 |
| #define EFSHLP_MAJOR 0 /* Get dynamically */ |
| #define EFSHLP_MINOR 0 |
| |
| #define USER_PART_OFFSET 0 |
| |
| static int efshlp_major; |
| static unsigned long efshlp_is_open; |
| static struct cdev efshlp_cdev; |
| static struct class *efshlp_class; |
| |
| #define EFS_DMA_HANDLE_SIGNATURE 0x55aa |
| |
| static int efs_handle_copy_dma(struct efshlp_dma *pdma) |
| { |
| |
| int done = 0, offset = pdma->offset; |
| struct map_info *map; |
| unsigned char *kernelbufaddr; |
| unsigned char *addr = kzalloc(pdma->size, GFP_KERNEL); |
| kernelbufaddr = addr; |
| |
| if (copy_from_user((void *) kernelbufaddr, (void *)pdma->buf, |
| pdma->size)) |
| return -EFAULT; |
| |
| pr_debug("%s\n", __func__); |
| |
| if (offset & 3) { |
| map = get_map_info(pdma->bank); |
| tegra_nor_copy_from(map, (void *) kernelbufaddr, |
| (offset & ~3), 4); |
| if (copy_to_user(pdma->buf, |
| (void *)(kernelbufaddr + (offset & 3)), |
| pdma->size < (4 - (offset & 3)) |
| ? pdma->size |
| : (4 - (offset & 3)) |
| )) { |
| kfree(addr); |
| return -EFAULT; |
| } |
| pdma->buf += (4 - (offset & 3)); |
| done += (4 - (offset & 3)); |
| kernelbufaddr += (4 - (offset & 3)); |
| offset += (4 - (offset & 3)); |
| } |
| |
| while (done < pdma->size) { |
| |
| if ((pdma->size - done) > FLASHDMA_DMABUFSIZE) { |
| |
| map = get_map_info(pdma->bank); |
| tegra_nor_copy_from(map, (void *) kernelbufaddr, |
| offset, FLASHDMA_DMABUFSIZE); |
| |
| if (copy_to_user(pdma->buf, (void *)kernelbufaddr, |
| FLASHDMA_DMABUFSIZE)) { |
| kfree(addr); |
| return -EFAULT; |
| |
| } |
| |
| offset += FLASHDMA_DMABUFSIZE; |
| pdma->buf += FLASHDMA_DMABUFSIZE; |
| done += FLASHDMA_DMABUFSIZE; |
| kernelbufaddr += FLASHDMA_DMABUFSIZE; |
| |
| } else { |
| |
| map = get_map_info(pdma->bank); |
| |
| tegra_nor_copy_from(map, (void *) kernelbufaddr, |
| offset, pdma->size - done); |
| |
| if (copy_to_user(pdma->buf, (void *)kernelbufaddr, |
| pdma->size - done)) { |
| kfree(addr); |
| return -EFAULT; |
| } |
| |
| offset += pdma->size - done; |
| done += pdma->size - done; |
| pdma->buf += pdma->size - done; |
| kernelbufaddr += pdma->size - done; |
| } |
| } |
| |
| kfree(addr); |
| return pdma->size; |
| } |
| |
| static int efs_handle_mmap_dma(struct efshlp_dma *pdma, |
| struct efs_dma_handle *handle, struct vm_area_struct *vma) |
| { |
| unsigned long curaddr, virtaddr, offset; |
| unsigned int i; |
| unsigned long kernvirtaddr; |
| long pdma_size = pdma->size; |
| struct map_info *map; |
| |
| pr_debug("%s\n", __func__); |
| |
| if ((unsigned long)pdma->buf != vma->vm_start) { |
| /* buffer address is not the start address returned from |
| * EfsAllocBuf */ |
| kernvirtaddr = (unsigned long)handle->virtaddr + |
| ((unsigned long)pdma->buf - |
| (unsigned long)vma->vm_start); |
| |
| pr_debug("%s: Allocated buffer not at start, kernVirtAddr=%lx\n", |
| __func__, kernvirtaddr); |
| |
| } else { |
| kernvirtaddr = (unsigned long)handle->virtaddr; |
| } |
| |
| curaddr = kernvirtaddr; |
| virtaddr = kernvirtaddr; |
| offset = pdma->offset; |
| map = get_map_info(pdma->bank); |
| if (pdma_size >= PAGE_SIZE) { |
| virtaddr = (unsigned long)(kernvirtaddr + |
| (PAGE_SIZE - (kernvirtaddr % PAGE_SIZE))); |
| |
| tegra_nor_copy_from(map, (void *)(curaddr + |
| (kernvirtaddr % PAGE_SIZE)), pdma->offset, |
| PAGE_SIZE - (kernvirtaddr % PAGE_SIZE)); |
| |
| pdma_size = pdma_size - |
| (PAGE_SIZE - (kernvirtaddr % PAGE_SIZE)); |
| |
| offset = pdma->offset + PAGE_SIZE - (kernvirtaddr % PAGE_SIZE); |
| } |
| |
| for (i = 0; i < (pdma_size / PAGE_SIZE); i++) { |
| |
| curaddr = virtaddr; |
| virtaddr += PAGE_SIZE; |
| map = get_map_info(pdma->bank); |
| |
| tegra_nor_copy_from(map, (void *)curaddr, |
| offset, PAGE_SIZE); |
| pdma_size = pdma_size - PAGE_SIZE; |
| |
| offset += PAGE_SIZE; |
| } |
| |
| curaddr = virtaddr; |
| map = get_map_info(pdma->bank); |
| |
| if (pdma_size > 0) { |
| tegra_nor_copy_from(map, (void *) curaddr, offset, |
| pdma_size); |
| } |
| return pdma->size; |
| } |
| |
| static long efshlp_ioctl(struct file *file, unsigned int cmd, |
| unsigned long arg) |
| { |
| |
| struct efs_flash_info flash_info; |
| struct efshlp_dma pdma; |
| struct efs_dma_handle *handle; |
| struct vm_area_struct *vma; |
| int retval, i = 0; |
| struct map_info *map; |
| |
| switch (cmd) { |
| case EFSHLP_INIT: |
| |
| flash_info.total_flash_size = getflashsize(); |
| flash_info.user_part_size = getflashsize(); |
| flash_info.user_part_ofs = USER_PART_OFFSET; |
| flash_info.nbanks = get_maps_no(); |
| |
| for (i = 0; i < flash_info.nbanks; i++) { |
| |
| map = get_map_info(i); |
| flash_info.bank_addr[i] = (unsigned long)map->virt; |
| flash_info.bank_size[i] = map->size; |
| flash_info.bank_switch_id[i] = i; |
| |
| } |
| |
| if (copy_to_user((void *)arg, (void *)&flash_info, |
| sizeof(flash_info))) |
| retval = -EFAULT; |
| else |
| retval = 0; |
| break; |
| |
| case EFSHLP_DO_DMA: |
| |
| if (copy_from_user((void *)&pdma, (void *)arg, |
| sizeof(pdma))) |
| return -EFAULT; |
| |
| pr_debug("DO DMA\n"); |
| vma = find_vma(current->mm, (unsigned long)pdma.buf); |
| |
| if (!vma) { |
| pr_debug("efs: No VMA found for read buffer!\n"); |
| retval = efs_handle_copy_dma(&pdma); |
| goto dma_done; |
| } |
| |
| handle = vma->vm_private_data; |
| |
| if (!handle) { |
| pr_debug("efs: cannot find dma handle in VMA!\n"); |
| retval = efs_handle_copy_dma(&pdma); |
| goto dma_done; |
| } |
| |
| if (handle->signature != EFS_DMA_HANDLE_SIGNATURE) { |
| pr_debug("efs: Invalid DMA handle!\n"); |
| retval = efs_handle_copy_dma(&pdma); |
| goto dma_done; |
| } |
| |
| /* check for allignment to dword * in both source and dst */ |
| |
| if (((unsigned long)pdma.buf | |
| (unsigned long)pdma.offset) & 3) { |
| |
| pr_debug("Alignment check failed, performing copydma!\n"); |
| retval = efs_handle_copy_dma(&pdma); |
| goto dma_done; |
| } |
| |
| retval = efs_handle_mmap_dma(&pdma, handle, vma); |
| |
| dma_done: |
| break; |
| |
| case EFSHLP_GET_ALLOC_SIZE: |
| |
| vma = find_vma(current->mm, (unsigned long)arg); |
| |
| if (!vma) { |
| pr_debug("ALLOC null\n"); |
| return -1; |
| } |
| |
| handle = vma->vm_private_data; |
| |
| if (!handle) { |
| pr_debug("ALLOC no handle\n"); |
| return -1; |
| } |
| |
| if (handle->signature != EFS_DMA_HANDLE_SIGNATURE) { |
| pr_debug("ALLOC no sigature\n"); |
| return -1; |
| } |
| |
| retval = handle->size; |
| break; |
| |
| default: |
| retval = -1; |
| break; |
| } |
| |
| return retval; |
| } |
| |
| static void efshlp_mmap_open(struct vm_area_struct *area) |
| { |
| |
| struct efs_dma_handle *handle = area->vm_private_data; |
| |
| pr_debug("Allocating map %p %p %i\n", handle->virtaddr, |
| (void *)handle->phyaddr, handle->size); |
| |
| handle->mapcount++; |
| } |
| |
| static void efshlp_mmap_close(struct vm_area_struct *area) |
| { |
| |
| int i; |
| struct efs_dma_handle *handle = area->vm_private_data; |
| |
| handle->mapcount--; |
| |
| if (!handle->mapcount) { |
| |
| pr_debug("Freeing map %p %p %i\n", handle->virtaddr, |
| (void *)handle->phyaddr, handle->size); |
| |
| /* all references to this map have been freed */ |
| |
| for (i = 0; i < handle->size; i += 4096) |
| ClearPageReserved(vmalloc_to_page(handle->virtaddr+i)); |
| |
| vfree(handle->virtaddr); |
| kfree(handle); |
| } |
| } |
| |
| struct vm_operations_struct vmops = { |
| .open = efshlp_mmap_open, |
| .close = efshlp_mmap_close |
| }; |
| |
| static int efshlp_mmap(struct file *filp, struct vm_area_struct *vma) |
| { |
| size_t size = vma->vm_end - vma->vm_start; |
| unsigned long i; |
| struct efs_dma_handle *handle; |
| |
| pr_debug("%s\n", __func__); |
| handle = kmalloc(sizeof(struct efs_dma_handle), GFP_KERNEL); |
| |
| if (!handle) { |
| printk(KERN_ERR "efs: failed to allocate dma handle mem\n"); |
| return -ENOMEM; |
| } |
| |
| handle->size = size; |
| handle->mapcount = 1; |
| handle->signature = EFS_DMA_HANDLE_SIGNATURE; |
| |
| handle->virtaddr = vmalloc(size); |
| |
| if (!handle->virtaddr) { |
| printk(KERN_ERR "DMA KERNEL ALLOC FAILED\n"); |
| kfree(handle); |
| return -ENOMEM; |
| } |
| |
| /* map to userspace, one page at a time */ |
| for (i = 0 ; i < size ; i += PAGE_SIZE) { |
| SetPageReserved(vmalloc_to_page(handle->virtaddr+i)); |
| |
| remap_pfn_range(vma, vma->vm_start + i, |
| vmalloc_to_pfn(handle->virtaddr+i), |
| PAGE_SIZE, vma->vm_page_prot); |
| } |
| |
| vma->vm_ops = &vmops; |
| vma->vm_private_data = (void *) handle; |
| |
| return 0; |
| } |
| |
| static int efshlp_open(struct inode *inode, struct file *file) |
| { |
| /* Only one active open supported */ |
| |
| if (test_and_set_bit(0, &efshlp_is_open)) |
| return -EBUSY; |
| |
| return 0; |
| } |
| |
| static int efshlp_close(struct inode *inode, struct file *file) |
| { |
| /* TODO: freeup all allocated memory here */ |
| clear_bit(0, &efshlp_is_open); |
| return 0; |
| } |
| |
| static const struct file_operations efshlp_fops = { |
| .owner = THIS_MODULE, |
| .unlocked_ioctl = efshlp_ioctl, |
| .open = efshlp_open, |
| .mmap = efshlp_mmap, |
| .release = efshlp_close, |
| }; |
| |
| |
| static void efshlp_cleanup(void) |
| { |
| |
| cdev_del(&efshlp_cdev); |
| device_destroy(efshlp_class, MKDEV(efshlp_major, EFSHLP_MINOR)); |
| |
| if (efshlp_class) |
| class_destroy(efshlp_class); |
| |
| unregister_chrdev(efshlp_major, EFSHLP_DEVICE); |
| } |
| |
| static int __init efshlp_init(void) |
| { |
| int result; |
| int ret = -ENODEV; |
| dev_t efshlp_dev ; |
| |
| printk(KERN_INFO "EFS helper driver\n"); |
| |
| result = alloc_chrdev_region(&efshlp_dev, 0, |
| EFSHLP_DEVICE_NO, EFSHLP_DEVICE); |
| |
| efshlp_major = MAJOR(efshlp_dev); |
| |
| if (result < 0) { |
| printk(KERN_ERR "alloc_chrdev_region() failed for efshlp\n"); |
| goto fail_err; |
| } |
| |
| /* Register a character device. */ |
| cdev_init(&efshlp_cdev, &efshlp_fops); |
| efshlp_cdev.owner = THIS_MODULE; |
| efshlp_cdev.ops = &efshlp_fops; |
| result = cdev_add(&efshlp_cdev, efshlp_dev, EFSHLP_DEVICE_NO); |
| |
| if (result < 0) |
| goto fail_chrdev; |
| |
| /* Create a sysfs class. */ |
| efshlp_class = class_create(THIS_MODULE, EFSHLP_DEVICE); |
| |
| if (IS_ERR(efshlp_class)) { |
| printk(KERN_ERR "efshlp: device class file already in use.\n"); |
| efshlp_cleanup(); |
| return PTR_ERR(efshlp_class); |
| } |
| |
| device_create(efshlp_class, NULL, |
| MKDEV(efshlp_major, EFSHLP_MINOR), |
| NULL, "%s", EFSHLP_DEVICE); |
| |
| return 0; |
| |
| fail_chrdev: |
| unregister_chrdev_region(efshlp_dev, EFSHLP_DEVICE_NO); |
| |
| fail_err: |
| return ret; |
| } |
| |
| static void __exit efshlp_exit(void) |
| { |
| device_destroy(efshlp_class, MKDEV(efshlp_major, EFSHLP_MINOR)); |
| |
| if (efshlp_class) |
| class_destroy(efshlp_class); |
| |
| cdev_del(&efshlp_cdev); |
| unregister_chrdev_region(MKDEV(efshlp_major, EFSHLP_MINOR), |
| EFSHLP_DEVICE_NO); |
| } |
| |
| module_init(efshlp_init); |
| module_exit(efshlp_exit); |
| MODULE_AUTHOR("Ashutosh Patel <ashutoshp@nvidia.com>"); |
| MODULE_LICENSE("GPL"); |