dhahelper.c

来自「linux下的MPEG1」· C语言 代码 · 共 1,240 行 · 第 1/3 页

			pci_write_config_byte(pdev,op.cmd,op.ret);
			break;
		    case 2:
			pci_write_config_word(pdev,op.cmd,op.ret);
			break;
		    case 4:
			pci_write_config_dword(pdev,op.cmd,op.ret);
			break;
		    default:
			if (dhahelper_verbosity > 0)
			    printk(KERN_ERR "dhahelper: wrong size of pci operation: %u \n",op.size);
			return -EFAULT;
		}
	    default:
		if (dhahelper_verbosity > 0)
		    printk(KERN_ERR "dhahelper: unknown pci operation %i\n",op.operation);
		return -EFAULT;
	}
	if (copy_to_user(arg, &op, sizeof(dhahelper_pci_device_t)))
	{
		if (dhahelper_verbosity > 0)
		    printk(KERN_ERR "dhahelper: failed copy to userspace\n");
		return -EFAULT;
	}
	return 0;
}

static int dhahelper_mtrr(dhahelper_mtrr_t *arg)
{
#ifdef CONFIG_MTRR
    dhahelper_mtrr_t op;
	if (copy_from_user(&op, arg, sizeof(dhahelper_pci_config_t)))
	{
		if (dhahelper_verbosity > 0)
		    printk(KERN_ERR "dhahelper: failed copy from userspace\n");
		return -EFAULT;
	}
	switch(op.operation)
	{
	    case MTRR_OP_ADD:
		op.privat = mtrr_add (op.start,op.size,op.type,1);
		break;
	    case MTRR_OP_DEL:
		mtrr_del(op.privat, op.start, op.size);
                break;
	    default:
		if (dhahelper_verbosity > 0)
		    printk(KERN_ERR "dhahelper: unknown mtrr operation %i\n",op.operation);
		return -EFAULT;
	}
	if (copy_to_user(arg, &op, sizeof(dhahelper_mtrr_t)))
	{
		if (dhahelper_verbosity > 0)
		    printk(KERN_ERR "dhahelper: failed copy to userspace\n");
		return -EFAULT;
	}
#endif
    return 0;
}

static int dhahelper_ioctl(struct inode *inode, struct file *file,
    unsigned int cmd, unsigned long arg)
{
    if (dhahelper_verbosity > 1)
	printk(KERN_DEBUG "dhahelper: ioctl(cmd=%x, arg=%lx)\n",
	    cmd, arg);

    if (MINOR(inode->i_rdev) != 0)
	return -ENXIO;

    switch(cmd)
    {
	case DHAHELPER_GET_VERSION: return dhahelper_get_version((int *)arg);
	case DHAHELPER_PORT:	    return dhahelper_port((dhahelper_port_t *)arg);
	case DHAHELPER_MTRR:	    return dhahelper_mtrr((dhahelper_mtrr_t *)arg);
	case DHAHELPER_PCI_CONFIG:  return dhahelper_pci_config((dhahelper_pci_config_t *)arg);
	case DHAHELPER_VIRT_TO_PHYS:return dhahelper_virt_to_phys((dhahelper_vmi_t *)arg);
	case DHAHELPER_VIRT_TO_BUS: return dhahelper_virt_to_bus((dhahelper_vmi_t *)arg);
	case DHAHELPER_ALLOC_PA:return dhahelper_alloc_pa((dhahelper_mem_t *)arg);
	case DHAHELPER_FREE_PA: return dhahelper_free_pa((dhahelper_mem_t *)arg);
	case DHAHELPER_LOCK_MEM: return dhahelper_lock_mem((dhahelper_mem_t *)arg);
	case DHAHELPER_UNLOCK_MEM: return dhahelper_unlock_mem((dhahelper_mem_t *)arg);
	case DHAHELPER_INSTALL_IRQ: return dhahelper_install_irq((dhahelper_irq_t *)arg);
	case DHAHELPER_ACK_IRQ: return dhahelper_ack_irq((dhahelper_irq_t *)arg);
	case DHAHELPER_FREE_IRQ: return dhahelper_free_irq((dhahelper_irq_t *)arg);
	case DHAHELPER_CPU_FLUSH: return dhahelper_cpu_flush((dhahelper_cpu_flush_t *)arg);
	case DHAHELPER_PCI_FIND: return dhahelper_pci_find((dhahelper_pci_device_t *)arg);
	default:
    	    if (dhahelper_verbosity > 0)
		printk(KERN_ERR "dhahelper: invalid ioctl (%x)\n", cmd);
	    return -EINVAL;
    }
    return 0;
}

/*
    fops functions were shamelessly stolen from linux-kernel project ;)
*/

static loff_t dhahelper_lseek(struct file * file, loff_t offset, int orig)
{
	switch (orig) {
		case 0:
			file->f_pos = offset;
			return file->f_pos;
		case 1:
			file->f_pos += offset;
			return file->f_pos;
		default:
			return -EINVAL;
	}
}

/*
 * This funcion reads the *physical* memory. The f_pos points directly to the 
 * memory location. 
 */
static ssize_t dhahelper_read(struct file * file, char * buf,
			size_t count, loff_t *ppos)
{
	unsigned long p = *ppos;
	unsigned long end_mem;
	ssize_t read;
	
	end_mem = __pa(high_memory);
	if (p >= end_mem)
		return 0;
	if (count > end_mem - p)
		count = end_mem - p;
	read = 0;
#if defined(__sparc__) || defined(__mc68000__)
	/* we don't have page 0 mapped on sparc and m68k.. */
	if (p < PAGE_SIZE) {
		unsigned long sz = PAGE_SIZE-p;
		if (sz > count) 
			sz = count; 
		if (sz > 0) {
			if (clear_user(buf, sz))
				return -EFAULT;
			buf += sz; 
			p += sz; 
			count -= sz; 
			read += sz; 
		}
	}
#endif
	if (copy_to_user(buf, __va(p), count))
		return -EFAULT;
	read += count;
	*ppos += read;
	return read;
}

static ssize_t do_write_mem(struct file * file, void *p, unsigned long realp,
			    const char * buf, size_t count, loff_t *ppos)
{
	ssize_t written;

	written = 0;
#if defined(__sparc__) || defined(__mc68000__)
	/* we don't have page 0 mapped on sparc and m68k.. */
	if (realp < PAGE_SIZE) {
		unsigned long sz = PAGE_SIZE-realp;
		if (sz > count) sz = count; 
		/* Hmm. Do something? */
		buf+=sz;
		p+=sz;
		count-=sz;
		written+=sz;
	}
#endif
	if (copy_from_user(p, buf, count))
		return -EFAULT;
	written += count;
	*ppos += written;
	return written;
}

static ssize_t dhahelper_write(struct file * file, const char * buf, 
			 size_t count, loff_t *ppos)
{
	unsigned long p = *ppos;
	unsigned long end_mem;

	end_mem = __pa(high_memory);
	if (p >= end_mem)
		return 0;
	if (count > end_mem - p)
		count = end_mem - p;
	return do_write_mem(file, __va(p), p, buf, count, ppos);
}

#ifndef pgprot_noncached

/*
 * This should probably be per-architecture in <asm/pgtable.h>
 */
static inline pgprot_t pgprot_noncached(pgprot_t _prot)
{
	unsigned long prot = pgprot_val(_prot);

#if defined(__i386__) || defined(__x86_64__)
	/* On PPro and successors, PCD alone doesn't always mean 
	    uncached because of interactions with the MTRRs. PCD | PWT
	    means definitely uncached. */ 
	if (boot_cpu_data.x86 > 3)
		prot |= _PAGE_PCD | _PAGE_PWT;
#elif defined(__powerpc__)
	prot |= _PAGE_NO_CACHE | _PAGE_GUARDED;
#elif defined(__mc68000__)
#ifdef SUN3_PAGE_NOCACHE
	if (MMU_IS_SUN3)
		prot |= SUN3_PAGE_NOCACHE;
	else
#endif
	if (MMU_IS_851 || MMU_IS_030)
		prot |= _PAGE_NOCACHE030;
	/* Use no-cache mode, serialized */
	else if (MMU_IS_040 || MMU_IS_060)
		prot = (prot & _CACHEMASK040) | _PAGE_NOCACHE_S;
#endif

	return __pgprot(prot);
}

#endif /* !pgprot_noncached */

/*
 * Architectures vary in how they handle caching for addresses 
 * outside of main memory.
 */
static inline int noncached_address(unsigned long addr)
{
#if defined(__i386__)
	/* 
	 * On the PPro and successors, the MTRRs are used to set
	 * memory types for physical addresses outside main memory, 
	 * so blindly setting PCD or PWT on those pages is wrong.
	 * For Pentiums and earlier, the surround logic should disable 
	 * caching for the high addresses through the KEN pin, but
	 * we maintain the tradition of paranoia in this code.
	 */
 	return !( test_bit(X86_FEATURE_MTRR, boot_cpu_data.x86_capability) ||
		  test_bit(X86_FEATURE_K6_MTRR, boot_cpu_data.x86_capability) ||
		  test_bit(X86_FEATURE_CYRIX_ARR, boot_cpu_data.x86_capability) ||
		  test_bit(X86_FEATURE_CENTAUR_MCR, boot_cpu_data.x86_capability) )
	  && addr >= __pa(high_memory);
#else
	return addr >= __pa(high_memory);
#endif
}

static int dhahelper_mmap(struct file * file, struct vm_area_struct * vma)
{
	unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
	int err;

	/*
	 * Accessing memory above the top the kernel knows about or
	 * through a file pointer that was marked O_SYNC will be
	 * done non-cached.
	 */
	if (noncached_address(offset) || (file->f_flags & O_SYNC))
		vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

	/* Don't try to swap out physical pages.. */
	vma->vm_flags |= VM_RESERVED;

	/*
	 * Don't dump addresses that are not real memory to a core file.
	 */
	if (offset >= __pa(high_memory) || (file->f_flags & O_SYNC))
		vma->vm_flags |= VM_IO;

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
	err = remap_page_range(vma, vma->vm_start, offset,
			       vma->vm_end-vma->vm_start, vma->vm_page_prot);
#else
	err = remap_page_range(vma->vm_start, offset,
			       vma->vm_end-vma->vm_start, vma->vm_page_prot);
#endif
	if(err)
		return -EAGAIN;
	return 0;
}

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
static struct file_operations dhahelper_fops =
{
    /*llseek*/	dhahelper_lseek,
    /*read*/	dhahelper_read,
    /*write*/	dhahelper_write,
    /*readdir*/	NULL,
    /*poll*/	NULL,
    /*ioctl*/	dhahelper_ioctl,
    /*mmap*/	dhahelper_mmap,
    /*open*/	dhahelper_open,
    /*flush*/	NULL,
    /*release*/	dhahelper_release,
    /* zero out the last 5 entries too ? */
};
#else
static struct file_operations dhahelper_fops =
{
    owner:	THIS_MODULE,
    ioctl:	dhahelper_ioctl,
    open:	dhahelper_open,
    release:	dhahelper_release,
    llseek:	dhahelper_lseek,
    read:	dhahelper_read,
    write:	dhahelper_write,
    mmap:	dhahelper_mmap,
};
#endif

#ifdef CONFIG_DEVFS_FS
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
devfs_handle_t dha_devfsh;

static int
register_dev(void)
{
    dha_devfsh = devfs_register(NULL, "dhahelper", DEVFS_FL_NONE,
				dhahelper_major, 0,
				S_IFCHR | S_IRUSR | S_IWUSR,
				&dhahelper_fops, NULL);
    if(!dha_devfsh)
	return -EIO;
    return 0;
}

static void
unregister_dev(void)
{
    devfs_unregister(dha_devfsh);
}
#else /* VERSION < 2.6.0 */
static int
register_dev(void)
{
    devfs_mk_cdev(MKDEV(dhahelper_major, 0), S_IFCHR | S_IRUSR | S_IWUSR,
		  "dhahelper");
    if(register_chrdev(dhahelper_major, "dhahelper", &dhahelper_fops))
	return -EIO;
    return 0;
}

static void
unregister_dev(void)
{
    devfs_remove("dhahelper");
    unregister_chrdev(dhahelper_major, "dhahelper");
}
#endif /* VERSION < 2.6.0 */
#else
static int
register_dev(void)
{
    return register_chrdev(dhahelper_major, "dhahelper", &dhahelper_fops);
}

static void
unregister_dev(void)
{
    unregister_chrdev(dhahelper_major, "dhahelper");
}
#endif /* defined CONFIG_DEVFS_FS */


#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
int init_module(void)
#else 
static int __init init_dhahelper(void)
#endif
{
    int err = 0;
    printk(KERN_INFO "Direct Hardware Access kernel helper (C) Alex Beregszaszi\n");

    err = register_dev();
    if(err){
    	if (dhahelper_verbosity > 0)
	    printk(KERN_ERR "dhahelper: unable to register character device (major: %d)\n",
		dhahelper_major);
	return err;
    }
    memset(dha_irqs, 0, sizeof(dha_irqs));
    return 0;
}

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
void cleanup_module(void)
#else
static void __exit exit_dhahelper(void)
#endif
{
    unsigned i;
    for(i=0;i<256;i++)
	if(dha_irqs[i].handled)
	    free_irq(i, dha_irqs[i].dev);

    unregister_dev();
}

#ifdef EXPORT_NO_SYMBOLS
EXPORT_NO_SYMBOLS;
#endif

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
module_init(init_dhahelper);
module_exit(exit_dhahelper);
#endif