1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * PCI Backend - Functions for creating a virtual configuration space for
4  *               exported PCI Devices.
5  *               It's dangerous to allow PCI Driver Domains to change their
6  *               device's resources (memory, i/o ports, interrupts). We need to
7  *               restrict changes to certain PCI Configuration registers:
8  *               BARs, INTERRUPT_PIN, most registers in the header...
9  *
10  * Author: Ryan Wilson <hap9@epoch.ncsc.mil>
11  */
12 
13 #include <linux/kernel.h>
14 #include <linux/moduleparam.h>
15 #include <linux/pci.h>
16 #include "pciback.h"
17 #include "conf_space.h"
18 #include "conf_space_quirks.h"
19 
20 bool xen_pcibk_permissive;
21 module_param_named(permissive, xen_pcibk_permissive, bool, 0644);
22 
23 /* This is where xen_pcibk_read_config_byte, xen_pcibk_read_config_word,
24  * xen_pcibk_write_config_word, and xen_pcibk_write_config_byte are created. */
25 #define DEFINE_PCI_CONFIG(op, size, type)			\
26 int xen_pcibk_##op##_config_##size				\
27 (struct pci_dev *dev, int offset, type value, void *data)	\
28 {								\
29 	return pci_##op##_config_##size(dev, offset, value);	\
30 }
31 
32 DEFINE_PCI_CONFIG(read, byte, u8 *)
33 DEFINE_PCI_CONFIG(read, word, u16 *)
34 DEFINE_PCI_CONFIG(read, dword, u32 *)
35 
36 DEFINE_PCI_CONFIG(write, byte, u8)
37 DEFINE_PCI_CONFIG(write, word, u16)
38 DEFINE_PCI_CONFIG(write, dword, u32)
39 
40 static int conf_space_read(struct pci_dev *dev,
41 			   const struct config_field_entry *entry,
42 			   int offset, u32 *value)
43 {
44 	int ret = 0;
45 	const struct config_field *field = entry->field;
46 
47 	*value = 0;
48 
49 	switch (field->size) {
50 	case 1:
51 		if (field->u.b.read)
52 			ret = field->u.b.read(dev, offset, (u8 *) value,
53 					      entry->data);
54 		break;
55 	case 2:
56 		if (field->u.w.read)
57 			ret = field->u.w.read(dev, offset, (u16 *) value,
58 					      entry->data);
59 		break;
60 	case 4:
61 		if (field->u.dw.read)
62 			ret = field->u.dw.read(dev, offset, value, entry->data);
63 		break;
64 	}
65 	return ret;
66 }
67 
68 static int conf_space_write(struct pci_dev *dev,
69 			    const struct config_field_entry *entry,
70 			    int offset, u32 value)
71 {
72 	int ret = 0;
73 	const struct config_field *field = entry->field;
74 
75 	switch (field->size) {
76 	case 1:
77 		if (field->u.b.write)
78 			ret = field->u.b.write(dev, offset, (u8) value,
79 					       entry->data);
80 		break;
81 	case 2:
82 		if (field->u.w.write)
83 			ret = field->u.w.write(dev, offset, (u16) value,
84 					       entry->data);
85 		break;
86 	case 4:
87 		if (field->u.dw.write)
88 			ret = field->u.dw.write(dev, offset, value,
89 						entry->data);
90 		break;
91 	}
92 	return ret;
93 }
94 
95 static inline u32 get_mask(int size)
96 {
97 	if (size == 1)
98 		return 0xff;
99 	else if (size == 2)
100 		return 0xffff;
101 	else
102 		return 0xffffffff;
103 }
104 
105 static inline int valid_request(int offset, int size)
106 {
107 	/* Validate request (no un-aligned requests) */
108 	if ((size == 1 || size == 2 || size == 4) && (offset % size) == 0)
109 		return 1;
110 	return 0;
111 }
112 
113 static inline u32 merge_value(u32 val, u32 new_val, u32 new_val_mask,
114 			      int offset)
115 {
116 	if (offset >= 0) {
117 		new_val_mask <<= (offset * 8);
118 		new_val <<= (offset * 8);
119 	} else {
120 		new_val_mask >>= (offset * -8);
121 		new_val >>= (offset * -8);
122 	}
123 	val = (val & ~new_val_mask) | (new_val & new_val_mask);
124 
125 	return val;
126 }
127 
128 static int xen_pcibios_err_to_errno(int err)
129 {
130 	switch (err) {
131 	case PCIBIOS_SUCCESSFUL:
132 		return XEN_PCI_ERR_success;
133 	case PCIBIOS_DEVICE_NOT_FOUND:
134 		return XEN_PCI_ERR_dev_not_found;
135 	case PCIBIOS_BAD_REGISTER_NUMBER:
136 		return XEN_PCI_ERR_invalid_offset;
137 	case PCIBIOS_FUNC_NOT_SUPPORTED:
138 		return XEN_PCI_ERR_not_implemented;
139 	case PCIBIOS_SET_FAILED:
140 		return XEN_PCI_ERR_access_denied;
141 	}
142 	return err;
143 }
144 
145 int xen_pcibk_config_read(struct pci_dev *dev, int offset, int size,
146 			  u32 *ret_val)
147 {
148 	int err = 0;
149 	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);
150 	const struct config_field_entry *cfg_entry;
151 	const struct config_field *field;
152 	int field_start, field_end;
153 	/* if read fails for any reason, return 0
154 	 * (as if device didn't respond) */
155 	u32 value = 0, tmp_val;
156 
157 	if (unlikely(verbose_request))
158 		printk(KERN_DEBUG DRV_NAME ": %s: read %d bytes at 0x%x\n",
159 		       pci_name(dev), size, offset);
160 
161 	if (!valid_request(offset, size)) {
162 		err = XEN_PCI_ERR_invalid_offset;
163 		goto out;
164 	}
165 
166 	/* Get the real value first, then modify as appropriate */
167 	switch (size) {
168 	case 1:
169 		err = pci_read_config_byte(dev, offset, (u8 *) &value);
170 		break;
171 	case 2:
172 		err = pci_read_config_word(dev, offset, (u16 *) &value);
173 		break;
174 	case 4:
175 		err = pci_read_config_dword(dev, offset, &value);
176 		break;
177 	}
178 
179 	list_for_each_entry(cfg_entry, &dev_data->config_fields, list) {
180 		field = cfg_entry->field;
181 
182 		field_start = OFFSET(cfg_entry);
183 		field_end = OFFSET(cfg_entry) + field->size;
184 
185 		if (offset + size > field_start && field_end > offset) {
186 			err = conf_space_read(dev, cfg_entry, field_start,
187 					      &tmp_val);
188 			if (err)
189 				goto out;
190 
191 			value = merge_value(value, tmp_val,
192 					    get_mask(field->size),
193 					    field_start - offset);
194 		}
195 	}
196 
197 out:
198 	if (unlikely(verbose_request))
199 		printk(KERN_DEBUG DRV_NAME ": %s: read %d bytes at 0x%x = %x\n",
200 		       pci_name(dev), size, offset, value);
201 
202 	*ret_val = value;
203 	return xen_pcibios_err_to_errno(err);
204 }
205 
206 int xen_pcibk_config_write(struct pci_dev *dev, int offset, int size, u32 value)
207 {
208 	int err = 0, handled = 0;
209 	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);
210 	const struct config_field_entry *cfg_entry;
211 	const struct config_field *field;
212 	u32 tmp_val;
213 	int field_start, field_end;
214 
215 	if (unlikely(verbose_request))
216 		printk(KERN_DEBUG
217 		       DRV_NAME ": %s: write request %d bytes at 0x%x = %x\n",
218 		       pci_name(dev), size, offset, value);
219 
220 	if (!valid_request(offset, size))
221 		return XEN_PCI_ERR_invalid_offset;
222 
223 	list_for_each_entry(cfg_entry, &dev_data->config_fields, list) {
224 		field = cfg_entry->field;
225 
226 		field_start = OFFSET(cfg_entry);
227 		field_end = OFFSET(cfg_entry) + field->size;
228 
229 		if (offset + size > field_start && field_end > offset) {
230 			err = conf_space_read(dev, cfg_entry, field_start,
231 					      &tmp_val);
232 			if (err)
233 				break;
234 
235 			tmp_val = merge_value(tmp_val, value, get_mask(size),
236 					      offset - field_start);
237 
238 			err = conf_space_write(dev, cfg_entry, field_start,
239 					       tmp_val);
240 
241 			/* handled is set true here, but not every byte
242 			 * may have been written! Properly detecting if
243 			 * every byte is handled is unnecessary as the
244 			 * flag is used to detect devices that need
245 			 * special helpers to work correctly.
246 			 */
247 			handled = 1;
248 		}
249 	}
250 
251 	if (!handled && !err) {
252 		/* By default, anything not specificially handled above is
253 		 * read-only. The permissive flag changes this behavior so
254 		 * that anything not specifically handled above is writable.
255 		 * This means that some fields may still be read-only because
256 		 * they have entries in the config_field list that intercept
257 		 * the write and do nothing. */
258 		if (dev_data->permissive || xen_pcibk_permissive) {
259 			switch (size) {
260 			case 1:
261 				err = pci_write_config_byte(dev, offset,
262 							    (u8) value);
263 				break;
264 			case 2:
265 				err = pci_write_config_word(dev, offset,
266 							    (u16) value);
267 				break;
268 			case 4:
269 				err = pci_write_config_dword(dev, offset,
270 							     (u32) value);
271 				break;
272 			}
273 		} else if (!dev_data->warned_on_write) {
274 			dev_data->warned_on_write = 1;
275 			dev_warn(&dev->dev, "Driver tried to write to a "
276 				 "read-only configuration space field at offset"
277 				 " 0x%x, size %d. This may be harmless, but if "
278 				 "you have problems with your device:\n"
279 				 "1) see permissive attribute in sysfs\n"
280 				 "2) report problems to the xen-devel "
281 				 "mailing list along with details of your "
282 				 "device obtained from lspci.\n", offset, size);
283 		}
284 	}
285 
286 	return xen_pcibios_err_to_errno(err);
287 }
288 
289 void xen_pcibk_config_free_dyn_fields(struct pci_dev *dev)
290 {
291 	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);
292 	struct config_field_entry *cfg_entry, *t;
293 	const struct config_field *field;
294 
295 	dev_dbg(&dev->dev, "free-ing dynamically allocated virtual "
296 			   "configuration space fields\n");
297 	if (!dev_data)
298 		return;
299 
300 	list_for_each_entry_safe(cfg_entry, t, &dev_data->config_fields, list) {
301 		field = cfg_entry->field;
302 
303 		if (field->clean) {
304 			field->clean((struct config_field *)field);
305 
306 			kfree(cfg_entry->data);
307 
308 			list_del(&cfg_entry->list);
309 			kfree(cfg_entry);
310 		}
311 
312 	}
313 }
314 
315 void xen_pcibk_config_reset_dev(struct pci_dev *dev)
316 {
317 	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);
318 	const struct config_field_entry *cfg_entry;
319 	const struct config_field *field;
320 
321 	dev_dbg(&dev->dev, "resetting virtual configuration space\n");
322 	if (!dev_data)
323 		return;
324 
325 	list_for_each_entry(cfg_entry, &dev_data->config_fields, list) {
326 		field = cfg_entry->field;
327 
328 		if (field->reset)
329 			field->reset(dev, OFFSET(cfg_entry), cfg_entry->data);
330 	}
331 }
332 
333 void xen_pcibk_config_free_dev(struct pci_dev *dev)
334 {
335 	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);
336 	struct config_field_entry *cfg_entry, *t;
337 	const struct config_field *field;
338 
339 	dev_dbg(&dev->dev, "free-ing virtual configuration space fields\n");
340 	if (!dev_data)
341 		return;
342 
343 	list_for_each_entry_safe(cfg_entry, t, &dev_data->config_fields, list) {
344 		list_del(&cfg_entry->list);
345 
346 		field = cfg_entry->field;
347 
348 		if (field->release)
349 			field->release(dev, OFFSET(cfg_entry), cfg_entry->data);
350 
351 		kfree(cfg_entry);
352 	}
353 }
354 
355 int xen_pcibk_config_add_field_offset(struct pci_dev *dev,
356 				    const struct config_field *field,
357 				    unsigned int base_offset)
358 {
359 	int err = 0;
360 	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);
361 	struct config_field_entry *cfg_entry;
362 	void *tmp;
363 
364 	cfg_entry = kmalloc(sizeof(*cfg_entry), GFP_KERNEL);
365 	if (!cfg_entry) {
366 		err = -ENOMEM;
367 		goto out;
368 	}
369 
370 	cfg_entry->data = NULL;
371 	cfg_entry->field = field;
372 	cfg_entry->base_offset = base_offset;
373 
374 	/* silently ignore duplicate fields */
375 	err = xen_pcibk_field_is_dup(dev, OFFSET(cfg_entry));
376 	if (err)
377 		goto out;
378 
379 	if (field->init) {
380 		tmp = field->init(dev, OFFSET(cfg_entry));
381 
382 		if (IS_ERR(tmp)) {
383 			err = PTR_ERR(tmp);
384 			goto out;
385 		}
386 
387 		cfg_entry->data = tmp;
388 	}
389 
390 	dev_dbg(&dev->dev, "added config field at offset 0x%02x\n",
391 		OFFSET(cfg_entry));
392 	list_add_tail(&cfg_entry->list, &dev_data->config_fields);
393 
394 out:
395 	if (err)
396 		kfree(cfg_entry);
397 
398 	return err;
399 }
400 
401 /* This sets up the device's virtual configuration space to keep track of
402  * certain registers (like the base address registers (BARs) so that we can
403  * keep the client from manipulating them directly.
404  */
405 int xen_pcibk_config_init_dev(struct pci_dev *dev)
406 {
407 	int err = 0;
408 	struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);
409 
410 	dev_dbg(&dev->dev, "initializing virtual configuration space\n");
411 
412 	INIT_LIST_HEAD(&dev_data->config_fields);
413 
414 	err = xen_pcibk_config_header_add_fields(dev);
415 	if (err)
416 		goto out;
417 
418 	err = xen_pcibk_config_capability_add_fields(dev);
419 	if (err)
420 		goto out;
421 
422 	err = xen_pcibk_config_quirks_init(dev);
423 
424 out:
425 	return err;
426 }
427 
428 int xen_pcibk_config_init(void)
429 {
430 	return xen_pcibk_config_capability_init();
431 }
432