[PATCH] remove many unneeded #includes of sched.h
[linux-2.6.git] / drivers / pci / syscall.c
1 /*
2  *      pci_syscall.c
3  *
4  * For architectures where we want to allow direct access
5  * to the PCI config stuff - it would probably be preferable
6  * on PCs too, but there people just do it by hand with the
7  * magic northbridge registers..
8  */
9
10 #include <linux/errno.h>
11 #include <linux/pci.h>
12 #include <linux/smp_lock.h>
13 #include <linux/syscalls.h>
14 #include <asm/uaccess.h>
15 #include "pci.h"
16
17 asmlinkage long
18 sys_pciconfig_read(unsigned long bus, unsigned long dfn,
19                    unsigned long off, unsigned long len,
20                    void __user *buf)
21 {
22         struct pci_dev *dev;
23         u8 byte;
24         u16 word;
25         u32 dword;
26         long err, cfg_ret;
27
28         err = -EPERM;
29         if (!capable(CAP_SYS_ADMIN))
30                 goto error;
31
32         err = -ENODEV;
33         dev = pci_find_slot(bus, dfn);
34         if (!dev)
35                 goto error;
36
37         lock_kernel();
38         switch (len) {
39         case 1:
40                 cfg_ret = pci_user_read_config_byte(dev, off, &byte);
41                 break;
42         case 2:
43                 cfg_ret = pci_user_read_config_word(dev, off, &word);
44                 break;
45         case 4:
46                 cfg_ret = pci_user_read_config_dword(dev, off, &dword);
47                 break;
48         default:
49                 err = -EINVAL;
50                 unlock_kernel();
51                 goto error;
52         };
53         unlock_kernel();
54
55         err = -EIO;
56         if (cfg_ret != PCIBIOS_SUCCESSFUL)
57                 goto error;
58
59         switch (len) {
60         case 1:
61                 err = put_user(byte, (unsigned char __user *)buf);
62                 break;
63         case 2:
64                 err = put_user(word, (unsigned short __user *)buf);
65                 break;
66         case 4:
67                 err = put_user(dword, (unsigned int __user *)buf);
68                 break;
69         };
70         return err;
71
72 error:
73         /* ??? XFree86 doesn't even check the return value.  They
74            just look for 0xffffffff in the output, since that's what
75            they get instead of a machine check on x86.  */
76         switch (len) {
77         case 1:
78                 put_user(-1, (unsigned char __user *)buf);
79                 break;
80         case 2:
81                 put_user(-1, (unsigned short __user *)buf);
82                 break;
83         case 4:
84                 put_user(-1, (unsigned int __user *)buf);
85                 break;
86         };
87         return err;
88 }
89
90 asmlinkage long
91 sys_pciconfig_write(unsigned long bus, unsigned long dfn,
92                     unsigned long off, unsigned long len,
93                     void __user *buf)
94 {
95         struct pci_dev *dev;
96         u8 byte;
97         u16 word;
98         u32 dword;
99         int err = 0;
100
101         if (!capable(CAP_SYS_ADMIN))
102                 return -EPERM;
103
104         dev = pci_find_slot(bus, dfn);
105         if (!dev)
106                 return -ENODEV;
107
108         lock_kernel();
109         switch(len) {
110         case 1:
111                 err = get_user(byte, (u8 __user *)buf);
112                 if (err)
113                         break;
114                 err = pci_user_write_config_byte(dev, off, byte);
115                 if (err != PCIBIOS_SUCCESSFUL)
116                         err = -EIO;
117                 break;
118
119         case 2:
120                 err = get_user(word, (u16 __user *)buf);
121                 if (err)
122                         break;
123                 err = pci_user_write_config_word(dev, off, word);
124                 if (err != PCIBIOS_SUCCESSFUL)
125                         err = -EIO;
126                 break;
127
128         case 4:
129                 err = get_user(dword, (u32 __user *)buf);
130                 if (err)
131                         break;
132                 err = pci_user_write_config_dword(dev, off, dword);
133                 if (err != PCIBIOS_SUCCESSFUL)
134                         err = -EIO;
135                 break;
136
137         default:
138                 err = -EINVAL;
139                 break;
140         };
141         unlock_kernel();
142
143         return err;
144 }