PatchesAndForks/SvgaLib
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
SvgaLib/kernel/svgalib_helper/main.c

778 lines
21 KiB
C
Raw Permalink Blame History

#include <linux/config.h>
#if defined (CONFIG_MODVERSIONS) && !defined (MODVERSIONS)
# define MODVERSIONS
#endif
#include <linux/kernel.h> /* printk() */
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */
#include <linux/types.h> /* size_t */
#include <linux/stddef.h>
#include <linux/proc_fs.h>
#include <linux/fcntl.h> /* O_ACCMODE */
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/pci.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/mm.h>
#include <linux/thread_info.h>
#include <linux/smp.h>
#include <linux/smp_lock.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/syscalls.h>
#define __KERNEL_SYSCALLS__
#include <linux/unistd.h>
asmlinkage long (*s_ioperm)(unsigned long from, unsigned long num, int turn_on);
#include <asm/processor.h>
#include <asm/uaccess.h>
#include <asm/system.h> /* cli(), *_flags */
#include <asm/segment.h> /* memcpy and such */
#include <asm/io.h>
#include <asm/pgtable.h>
#include <asm/irq.h>
#include "kernel26compat.h"
#include "svgalib_helper.h"
#include "vgaversion.h"
#include "i810.h"
#include "interrupt.h"
#include "displaystart.h"
int debug=0;
static int all_devices=0;
int num_devices=0;
static char *sdev_id="svgalib_helper";
static struct sh_pci_device *sh_pci_devs[MAX_NR_DEVICES];
static int irqs[MAX_NR_DEVICES];
#if (defined CONFIG_DEVFS_FS) && (!defined KERNEL_2_6)
static devfs_handle_t devfs_handle;
#endif
#if defined(KERNEL_2_6) && !defined(CONFIG_DEVFS_FS)
struct K_CLASS *svgalib_helper_class;
#endif
static int check_io_range(int port, int device) {
return 1;
}
static struct pci_dev *get_pci_dev(int pcipos, int minor) {
if(minor>=num_devices) return NULL;
if(minor>0) {
return sh_pci_devs[minor]->dev;
} else {
if(pcipos>0 && pcipos<num_devices)
return sh_pci_devs[pcipos]->dev;
}
return NULL;
}
static int get_dev(int pcipos, int minor) {
if(minor>=num_devices) return 0;
if(minor>0) {
return minor;
} else {
if(pcipos>=num_devices || pcipos<1) return 0;
return pcipos;
}
}
static volatile int vsync=0;
static wait_queue_head_t vsync_wait;
static irqreturn_t vsync_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct sh_pci_device *dev = (struct sh_pci_device *)dev_id;
if((char *)dev==sdev_id) {
if(!vga_test_vsync(dev)) {
return IRQ_NONE;
}
vga_ack_vsync(dev);
vsync=0;
wake_up_interruptible(&vsync_wait);
} else {
if(!dev->test_vsync(dev)) {
return IRQ_NONE;
}
dev->ack_vsync(dev);
dev->vsync=0;
wake_up_interruptible(&dev->vsync_wait);
#ifndef NO_TASK
wake_up_interruptible(&dev->startad_wait);
#endif
}
return IRQ_HANDLED;
}
#ifndef NO_TASK
static void task_startad(void *data) {
struct sh_pci_device *dev = (struct sh_pci_device *)data;
int i;
i=dev->dev->irq;
dev->enable_vsync(dev);
interruptible_sleep_on(&dev->vsync_wait);
dev->ack_vsync(dev);
set_displaystart(dev);
dev->startad=-1;
}
#endif
#define GET_IOSTR \
get_user(iostr.port, &user_iostr->port); \
get_user(iostr.length, &user_iostr->length); \
get_user(iostr.string, &user_iostr->string);
#define GET_IOV \
get_user(iov.port, &user_iov->port); \
get_user(iov.val, &user_iov->val);
#define PUT_IOV \
put_user(iov.val, &user_iov->val);
#define GET_PCIV \
get_user(pciv.pcipos, &user_pciv->pcipos); \
get_user(pciv.address, &user_pciv->address); \
get_user(pciv.val, &user_pciv->val);
#define PUT_PCIV \
put_user(pciv.val, &user_pciv->val);
static int svgalib_helper_ioctl( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg) {
io_t iov, *user_iov=(io_t *)arg;
pcic_t pciv, *user_pciv=(pcic_t *)arg;
int minor = my_minor(inode->i_rdev);
struct pci_dev *pdev;
io_string_t iostr, *user_iostr=(io_string_t *)arg;
int i=0, ret;
u8 pb;
u16 pw;
u32 pl;
unsigned char *outb_str;
if(_IOC_TYPE(cmd)!=SVGAHELPER_MAGIC) {
return -EINVAL;
}
ret=0;
switch(_IOC_NR(cmd)) {
case _IOC_NR(SVGAHELPER_REPOUTB):
GET_IOSTR;
if (iostr.length>4096) return -EINVAL;
if ( (outb_str = kmalloc(iostr.length, GFP_KERNEL )) == NULL ) return -ENOMEM;
if(copy_from_user(outb_str,iostr.string,iostr.length)) return -EPERM;
if(check_io_range(iostr.port,minor)) {
for(i=0; i<iostr.length; i++) outb(outb_str[i], iostr.port);
} else ret = -EPERM;
kfree (outb_str);
break;
case _IOC_NR(SVGAHELPER_OUTB):
GET_IOV;
if(check_io_range(iov.port,minor))
outb(iov.val,iov.port);
else ret = -EPERM;
break;
case _IOC_NR(SVGAHELPER_OUTW):
GET_IOV;
if(check_io_range(iov.port,minor))
outw(iov.val,iov.port);
else ret = -EPERM;
break;
case _IOC_NR(SVGAHELPER_OUTL):
GET_IOV;
if(check_io_range(iov.port,minor))
outl(iov.val,iov.port);
else ret = -EPERM;
break;
case _IOC_NR(SVGAHELPER_INB):
GET_IOV;
if(check_io_range(iov.port,minor))
iov.val=inb(iov.port);
else ret = -EPERM;
PUT_IOV;
break;
case _IOC_NR(SVGAHELPER_INW):
GET_IOV;
if(check_io_range(iov.port,minor))
iov.val=inw(iov.port);
else ret = -EPERM;
PUT_IOV;
break;
case _IOC_NR(SVGAHELPER_INL):
GET_IOV;
if(check_io_range(iov.port,minor))
iov.val=inl(iov.port);
else ret = -EPERM;
PUT_IOV;
break;
case _IOC_NR(SVGAHELPER_WRITEB):
GET_IOV;
writeb(iov.val,(u8 *)iov.port);
break;
case _IOC_NR(SVGAHELPER_WRITEW):
GET_IOV;
writew(iov.val,(u16 *)iov.port);
break;
case _IOC_NR(SVGAHELPER_WRITEL):
GET_IOV;
writel(iov.val,(u32 *)iov.port);
break;
case _IOC_NR(SVGAHELPER_READB):
GET_IOV;
iov.val=readb((u8 *)iov.port);
PUT_IOV;
break;
case _IOC_NR(SVGAHELPER_READW):
GET_IOV;
iov.val=readw((u16 *)iov.port);
PUT_IOV;
break;
case _IOC_NR(SVGAHELPER_READL):
GET_IOV;
iov.val=readl((u32 *)iov.port);
PUT_IOV;
break;
case _IOC_NR(SVGAHELPER_PCIINB):
GET_PCIV;
pdev = get_pci_dev(pciv.pcipos, minor);
if(!pdev) return -EINVAL;
pci_read_config_byte(pdev, pciv.address, &pb);
pciv.val=pb;
PUT_PCIV;
break;
case _IOC_NR(SVGAHELPER_PCIINW):
GET_PCIV;
pdev = get_pci_dev(pciv.pcipos, minor);
if(!pdev) return -EINVAL;
pci_read_config_word(pdev, pciv.address, &pw);
pciv.val=pw;
PUT_PCIV;
break;
case _IOC_NR(SVGAHELPER_PCIINL):
GET_PCIV;
pdev = get_pci_dev(pciv.pcipos, minor);
if(!pdev) return -EINVAL;
pci_read_config_dword(pdev, pciv.address, &pl);
pciv.val=pl;
PUT_PCIV;
break;
case _IOC_NR(SVGAHELPER_PCIAPLEN):
GET_PCIV;
i = get_dev(pciv.pcipos, minor);
if((i==0) | (pciv.address>5)) return -EINVAL;
pciv.val=sh_pci_devs[i]->len[pciv.address];
PUT_PCIV;
break;
case _IOC_NR(SVGAHELPER_PCIOUTB):
GET_PCIV;
pdev = get_pci_dev(pciv.pcipos, minor);
if(!pdev) return -EINVAL;
pb=pciv.val;
pci_write_config_byte(pdev, pciv.address, pb);
break;
case _IOC_NR(SVGAHELPER_PCIOUTW):
GET_PCIV;
pdev = get_pci_dev(pciv.pcipos, minor);
if(!pdev) return -EINVAL;
pw=pciv.val;
pci_write_config_word(pdev, pciv.address, pw);
break;
case _IOC_NR(SVGAHELPER_PCIOUTL):
GET_PCIV;
pdev = get_pci_dev(pciv.pcipos, minor);
if(!pdev) return -EINVAL;
pl=pciv.val;
pci_write_config_dword(pdev, pciv.address, pl);
break;
#ifdef __386__
case _IOC_NR(SVGAHELPER_I810GTT):
i=i810_make_gtt();
copy_to_user((char *)arg, &i, sizeof(unsigned int));
break;
case _IOC_NR(SVGAHELPER_I810GTTE):
copy_from_user(&i, (char *)arg, sizeof(unsigned int));
if(i<I810_SIZE)
copy_to_user((char *)arg, &i810_gttes[i], sizeof(unsigned long));
else return -EINVAL;
break;
#endif
case _IOC_NR(SVGAHELPER_WAITRETRACE):
/* Workaround for nvidia cards, which are not vga compatible */
// if(!minor && num_devices==2) minor=1;
if(minor) {
int i;
i=sh_pci_devs[minor]->dev->irq;
if(i==0 || i==-1 || i==255) return -EINVAL;
sh_pci_devs[minor]->vsync=1;
sh_pci_devs[minor]->enable_vsync(sh_pci_devs[minor]);
wait_event_interruptible(sh_pci_devs[minor]->vsync_wait,
!sh_pci_devs[minor]->vsync);
if(sh_pci_devs[minor]->vsync) sh_pci_devs[minor]->ack_vsync(sh_pci_devs[minor]);
if(sh_pci_devs[minor]->vsync) return -ERESTARTSYS;
} else {
int i;
vsync=1;
i=0;
while(irqs[i]!=-1)
request_irq(irqs[i++], vsync_interrupt, SA_SHIRQ, "svgalib_helper", sdev_id);
vga_enable_vsync((void *)sdev_id);
wait_event_interruptible(vsync_wait, !vsync);
i=0;
if(vsync) vga_ack_vsync((void *)sdev_id);
while(irqs[i]!=-1)
free_irq(irqs[i++], sdev_id);
if(vsync) return -ERESTARTSYS;
}
break;
#if 0
case _IOC_NR(SVGAHELPER_IOPERM):
if(minor) return -EPERM;
#if 1
i=0;
if(!capable(CAP_SYS_RAWIO)) {
i=1;
cap_raise(current->cap_effective, CAP_SYS_RAWIO);
}
s_ioperm=sys_call_table[__NR_ioperm];
s_ioperm(0,0x400,1);
if(i) {
cap_lower(current->cap_effective, CAP_SYS_RAWIO);
}
#else
if(!ioperm) {
struct thread_struct * t = &current->thread;
struct tss_struct * tss;
unsigned long *bitmap;
ioperm=1;
bitmap = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
if (!bitmap)
return -ENOMEM;
memset(bitmap, 0, IO_BITMAP_BYTES);
t->io_bitmap_ptr = bitmap;
tss = &per_cpu(init_tss, get_cpu());
t->io_bitmap_max = IO_BITMAP_BYTES;
tss->io_bitmap_base = INVALID_IO_BITMAP_OFFSET_LAZY;
put_cpu();
}
#endif
break;
#endif
#ifndef NO_TASK
case _IOC_NR(SVGAHELPER_SETDISPLAYSTART):
if(minor) {
if(sh_pci_devs[minor]->startad==-1)
schedule_task(&sh_pci_devs[minor]->tq_startad);
sh_pci_devs[minor]->startad=arg;
}
break;
#endif
#ifdef SVGA_HELPER_VIRTUAL
case _IOC_NR(SVGAHELPER_VIRT_TO_PHYS):
return dhahelper_virt_to_phys((dhahelper_vmi_t *)arg);
case _IOC_NR(SVGAHELPER_VIRT_TO_BUS):
return dhahelper_virt_to_bus((dhahelper_vmi_t *)arg);
case _IOC_NR(SVGAHELPER_ALLOC_PA):
return dhahelper_alloc_pa((dhahelper_mem_t *)arg);
case _IOC_NR(SVGAHELPER_FREE_PA):
return dhahelper_free_pa((dhahelper_mem_t *)arg);
case _IOC_NR(SVGAHELPER_LOCK_MEM):
return dhahelper_lock_mem((dhahelper_mem_t *)arg);
case _IOC_NR(SVGAHELPER_UNLOCK_MEM):
return dhahelper_unlock_mem((dhahelper_mem_t *)arg);
default:
#endif
return -EINVAL;
}
return ret;
}
static int svgalib_helper_open( struct inode *inode, struct file * filp) {
int minor = my_minor(inode->i_rdev);
if(minor>=num_devices) return -ENODEV;
if(minor) {
int i=sh_pci_devs[minor]->dev->irq;
sh_pci_devs[minor]->opencount++;
if(sh_pci_devs[minor]->opencount==1 && i!=0 && i!=-1 && i!=255)
request_irq(i, vsync_interrupt, SA_SHIRQ, "svgalib_helper", sh_pci_devs[minor]);
}
#ifndef KERNEL_2_6
MOD_INC_USE_COUNT;
#else
try_module_get(THIS_MODULE);
#endif
return 0;
}
static int svgalib_helper_release( struct inode *inode, struct file *filp) {
int minor = my_minor(inode->i_rdev);
if(minor) {
int i=sh_pci_devs[minor]->dev->irq;
sh_pci_devs[minor]->opencount--;
if(sh_pci_devs[minor]->opencount==0 && i!=0 && i!=-1 && i!=255) {
sh_pci_devs[minor]->disable_vsync(sh_pci_devs[minor]);
free_irq(i, sh_pci_devs[minor]);
}
}
#ifndef KERNEL_2_6
MOD_DEC_USE_COUNT;
#else
module_put(THIS_MODULE);
#endif
return 0;
}
int remap_cache(struct vm_area_struct *vma, unsigned long off) {
vma->vm_pgoff = off >> PAGE_SHIFT;
/* This is an IO map - tell maydump to skip this VMA */
vma->vm_flags |= VM_IO;
#if defined(__sparc_v9__)
vma->vm_flags |= (VM_SHM | VM_LOCKED);
if (my_io_remap_page_range(vma, vma->vm_start, off,
vma->vm_end - vma->vm_start, vma->vm_page_prot, 0))
return -EAGAIN;
#else
#if defined(__mc68000__)
#if defined(CONFIG_SUN3)
pgprot_val(vma->vm_page_prot) |= SUN3_PAGE_NOCACHE;
#else
if (CPU_IS_020_OR_030)
pgprot_val(vma->vm_page_prot) |= _PAGE_NOCACHE030;
if (CPU_IS_040_OR_060) {
pgprot_val(vma->vm_page_prot) &= _CACHEMASK040;
/* Use no-cache mode, serialized */
pgprot_val(vma->vm_page_prot) |= _PAGE_NOCACHE_S;
}
#endif
#elif defined(__powerpc__)
pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE|_PAGE_GUARDED;
#elif defined(__alpha__)
/* Caching is off in the I/O space quadrant by design. */
#elif defined(__i386__) || defined(__x86_64__)
if (boot_cpu_data.x86 > 3)
pgprot_val(vma->vm_page_prot) |= _PAGE_PCD;
#elif defined(__arm__) || defined(__mips__)
vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
#elif defined(__sh__)
pgprot_val(vma->vm_page_prot) &= ~_PAGE_CACHABLE;
#elif defined(__hppa__)
pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE;
#elif defined(__ia64__)
vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
#else
#warning What do we have to do here??
#endif
if (my_io_remap_page_range(vma, vma->vm_start, off,
vma->vm_end - vma->vm_start, vma->vm_page_prot))
return -EAGAIN;
#endif /* !__sparc_v9__ */
return 0;
}
int check_mem(int card, unsigned long start, unsigned long len) {
int j;
unsigned long rstart, rlen;
#ifdef __alpha__
int type;
#endif
if (start+len < start || len >= 0x40000000) return -3;
rstart=start;
rlen=len;
#ifdef __alpha__
type = start>>32;
switch(type) {
case 2:
start = start & 0xffffffff;
start = start >> 5;
len = len >> 5;
break;
case 3:
start = start & 0xffffffff;
break;
default:
return -1;
}
#endif
if(!card) {
if( (start<0x110000) && (start+len<0x110000) ) return 0;
for(j=1;j<num_devices;j++)
if(!check_mem(j, rstart, rlen)) return 0;
} else if(card<num_devices) {
for(j=0;j<6;j++) if(sh_pci_devs[card]->mem[j])
if((start>=sh_pci_devs[card]->mem[j])&&
(start+len<=sh_pci_devs[card]->mem[j]+sh_pci_devs[card]->len[j])) {
return 0;
}
}
return -2;
}
static int svgalib_helper_mmap(struct file *filp, struct vm_area_struct *vma) {
unsigned long start=vma->vm_start;
unsigned long end=vma->vm_end;
unsigned long minor = my_minor(filp->f_dentry->d_inode->i_rdev);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
unsigned long ofs=vma->vm_pgoff*PAGE_SIZE;
#else
unsigned long ofs=vma->vm_offset;
#endif
if(check_mem(minor, ofs, end-start)) return -EPERM;
if(remap_cache(vma, ofs)) return -EAGAIN;
return 0;
}
struct file_operations svgalib_helper_fops = {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
.owner = THIS_MODULE,
#endif
.ioctl = svgalib_helper_ioctl,
.mmap = svgalib_helper_mmap,
.open = svgalib_helper_open,
.release = svgalib_helper_release,
};
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,3,0)
#define base_address(i) dev->resource[i].start
#else
#define base_address(i) (dev->base_address[i]&PCI_BASE_ADDRESS_MEM_MASK)
#endif
int init_module(void)
{
int result, i, j;
struct pci_dev *dev=NULL;
char name[255];
#ifdef CONFIG_DEVFS_FS
# ifndef KERNEL_2_6
devfs_handle_t slave_handle;
# endif
#endif
/*
* Register your major, and accept a dynamic number
*/
printk(KERN_INFO "svgalib_helper: Initializing, version %s\n", versionstr);
result = devfs_register_chrdev(SVGALIB_HELPER_MAJOR, "svgalib_helper", &svgalib_helper_fops);
if (result < 0) {
printk(KERN_WARNING "svgalib_helper: can't get major %d\n",SVGALIB_HELPER_MAJOR);
return result;
}
if((sh_pci_devs[0]=kmalloc(sizeof(struct sh_pci_device),GFP_KERNEL))==NULL) {
goto nomem_error;
}
memset(sh_pci_devs[0],0,sizeof(struct sh_pci_device));
num_devices=1;
for(i=1;i<MAX_NR_DEVICES;i++) sh_pci_devs[i]=NULL;
#ifdef CONFIG_DEVFS_FS
# ifndef KERNEL_2_6
devfs_handle = devfs_mk_dir ( NULL, "svga_helper", NULL );
devfs_register_series( devfs_handle,
"%u", 8, DEVFS_FL_DEFAULT, SVGALIB_HELPER_MAJOR, 0,
S_IFCHR | S_IRUGO | S_IRWXU, &svgalib_helper_fops, NULL ) ;
DEVFS_MK_SYMLINK( NULL, "svga", 0, "svga_helper/0", &slave_handle, NULL );
devfs_auto_unregister( devfs_handle, slave_handle );
# else
devfs_mk_dir ("svga_helper");
for (i = 0; i < 8; i++) {
devfs_mk_cdev(MKDEV(SVGALIB_HELPER_MAJOR, i),
S_IFCHR | S_IRUGO | S_IRWXU, "svga_helper/%d", i);
}
DEVFS_MK_SYMLINK("svga", "svga_helper/0");
# endif
#endif /* devfsd support */
SLH_SYSFS_REGISTER;
SLH_SYSFS_ADD_CONTROL;
if(pci_present()) {
while((dev= all_devices ?
PCI_GET_DEVICE(PCI_ANY_ID, PCI_ANY_ID, dev) :
PCI_GET_CLASS(PCI_CLASS_DISPLAY_VGA<<8,dev)) &&
(num_devices<=MAX_NR_DEVICES)) {
if((sh_pci_devs[num_devices]=kmalloc(sizeof(struct sh_pci_device),GFP_KERNEL))==NULL) {
goto nomem_error;
}
memset(sh_pci_devs[num_devices],0,sizeof(struct sh_pci_device));
sh_pci_devs[num_devices]->dev=dev;
pci_read_config_word(dev,0,&sh_pci_devs[num_devices]->vendor);
pci_read_config_word(dev,2,&sh_pci_devs[num_devices]->id);
pci_read_config_byte(dev,8,&sh_pci_devs[num_devices]->revision);
printk(KERN_DEBUG "svgalib_helper: device%d: vendor:%.4x id:%.4x\n",num_devices,
sh_pci_devs[num_devices]->vendor,sh_pci_devs[num_devices]->id);
for(i=0;i<6;i++){
unsigned int t;
int len;
pci_read_config_dword(dev,16+4*i,&result);
if(result) {
pci_write_config_dword(dev,16+4*i,0xffffffff);
pci_read_config_dword(dev,16+4*i,&t);
pci_write_config_dword(dev,16+4*i,result);
len = ~(t&~0xf)+1;
if (len){
sh_pci_devs[num_devices]->mem[i]=result&~0xf;
sh_pci_devs[num_devices]->flags[i]=0x80 | (result&0xf);
sh_pci_devs[num_devices]->len[i]=len;
sh_pci_devs[num_devices]->mask[i]=t&~0xf;
printk(KERN_DEBUG "device%d: region%d, base=%.8x len=%d type=%d\n",
num_devices,i, result&(~0xf), len, result&0xf);
}
}
}
vga_init_vsync(sh_pci_devs[num_devices]);
init_waitqueue_head(&sh_pci_devs[num_devices]->vsync_wait);
#ifndef NO_TASK
init_waitqueue_head(&sh_pci_devs[num_devices]->startad_wait);
sh_pci_devs[num_devices]->tq_startad.routine=task_startad;
sh_pci_devs[num_devices]->tq_startad.data=sh_pci_devs[num_devices];
sh_pci_devs[num_devices]->tq_startad.sync=0;
sh_pci_devs[num_devices]->startad=-1;
#endif
sh_pci_devs[num_devices]->opencount=0;
sprintf(name, "svga%d", num_devices);
SLH_SYSFS_ADD_DEVICE(name, num_devices);
num_devices++;
}
}
j=0;
for(i=1; i<num_devices;i++) {
int k, l;
k=sh_pci_devs[i]->dev->irq;
if(k>0 && k<255) {
for(l=0;l<j;l++) if(k==irqs[l])k=-1;
if(k>0) {
irqs[j]=k;
j++;
}
}
}
irqs[j]=-1;
init_waitqueue_head(&vsync_wait);
#ifndef KERNEL_2_6
EXPORT_NO_SYMBOLS;
#endif
return 0; /* succeed */
nomem_error:
for(i=0;i<MAX_NR_DEVICES;i++)
if(sh_pci_devs[i]) {
SLH_SYSFS_REMOVE_DEVICE(i);
kfree(sh_pci_devs[i]);
}
SLH_SYSFS_UNREGISTER;
devfs_unregister_chrdev(SVGALIB_HELPER_MAJOR, "svgalib_helper");
return result;
}
void cleanup_module(void)
{
int i;
for(i=0;i<MAX_NR_DEVICES;i++)
if(sh_pci_devs[i]) {
SLH_SYSFS_REMOVE_DEVICE(i);
kfree(sh_pci_devs[i]);
}
SLH_SYSFS_UNREGISTER;
#ifdef CONFIG_DEVFS_FS
# ifndef KERNEL_2_6
devfs_unregister(devfs_handle);
# else
for (i = 0; i < 8; i++)
devfs_remove("svga_helper/%d", i);
devfs_remove("svga_helper");
# endif
#endif
devfs_unregister_chrdev(SVGALIB_HELPER_MAJOR, "svgalib_helper");
}
MODULE_PARM(debug, "i");
MODULE_PARM_DESC(debug, "Debug output level.");
MODULE_PARM(all_devices, "i");
MODULE_PARM_DESC(all_devices, "Give access to all PCI devices, regardless of class.");
#ifdef MODULE_LICENSE
MODULE_LICENSE("GPL");
#endif
MODULE_AUTHOR("Matan Ziv-Av <matan@svgalib.org>");
MODULE_DESCRIPTION("Generic hardware access to vga cards");
Reference in a new issue View git blame Copy permalink