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