2 * PCI Backend - Functions for creating a virtual configuration space for
3 * exported PCI Devices.
4 * It's dangerous to allow PCI Driver Domains to change their
5 * device's resources (memory, i/o ports, interrupts). We need to
6 * restrict changes to certain PCI Configuration registers:
7 * BARs, INTERRUPT_PIN, most registers in the header...
9 * Author: Ryan Wilson <hap9@epoch.ncsc.mil>
12 #include <linux/kernel.h>
13 #include <linux/moduleparam.h>
14 #include <linux/pci.h>
16 #include "conf_space.h"
17 #include "conf_space_quirks.h"
19 bool xen_pcibk_permissive
;
20 module_param_named(permissive
, xen_pcibk_permissive
, bool, 0644);
22 /* This is where xen_pcibk_read_config_byte, xen_pcibk_read_config_word,
23 * xen_pcibk_write_config_word, and xen_pcibk_write_config_byte are created. */
24 #define DEFINE_PCI_CONFIG(op, size, type) \
25 int xen_pcibk_##op##_config_##size \
26 (struct pci_dev *dev, int offset, type value, void *data) \
28 return pci_##op##_config_##size(dev, offset, value); \
31 DEFINE_PCI_CONFIG(read
, byte
, u8
*)
32 DEFINE_PCI_CONFIG(read
, word
, u16
*)
33 DEFINE_PCI_CONFIG(read
, dword
, u32
*)
35 DEFINE_PCI_CONFIG(write
, byte
, u8
)
36 DEFINE_PCI_CONFIG(write
, word
, u16
)
37 DEFINE_PCI_CONFIG(write
, dword
, u32
)
39 static int conf_space_read(struct pci_dev
*dev
,
40 const struct config_field_entry
*entry
,
41 int offset
, u32
*value
)
44 const struct config_field
*field
= entry
->field
;
48 switch (field
->size
) {
51 ret
= field
->u
.b
.read(dev
, offset
, (u8
*) value
,
56 ret
= field
->u
.w
.read(dev
, offset
, (u16
*) value
,
61 ret
= field
->u
.dw
.read(dev
, offset
, value
, entry
->data
);
67 static int conf_space_write(struct pci_dev
*dev
,
68 const struct config_field_entry
*entry
,
69 int offset
, u32 value
)
72 const struct config_field
*field
= entry
->field
;
74 switch (field
->size
) {
77 ret
= field
->u
.b
.write(dev
, offset
, (u8
) value
,
82 ret
= field
->u
.w
.write(dev
, offset
, (u16
) value
,
86 if (field
->u
.dw
.write
)
87 ret
= field
->u
.dw
.write(dev
, offset
, value
,
94 static inline u32
get_mask(int size
)
104 static inline int valid_request(int offset
, int size
)
106 /* Validate request (no un-aligned requests) */
107 if ((size
== 1 || size
== 2 || size
== 4) && (offset
% size
) == 0)
112 static inline u32
merge_value(u32 val
, u32 new_val
, u32 new_val_mask
,
116 new_val_mask
<<= (offset
* 8);
117 new_val
<<= (offset
* 8);
119 new_val_mask
>>= (offset
* -8);
120 new_val
>>= (offset
* -8);
122 val
= (val
& ~new_val_mask
) | (new_val
& new_val_mask
);
127 static int xen_pcibios_err_to_errno(int err
)
130 case PCIBIOS_SUCCESSFUL
:
131 return XEN_PCI_ERR_success
;
132 case PCIBIOS_DEVICE_NOT_FOUND
:
133 return XEN_PCI_ERR_dev_not_found
;
134 case PCIBIOS_BAD_REGISTER_NUMBER
:
135 return XEN_PCI_ERR_invalid_offset
;
136 case PCIBIOS_FUNC_NOT_SUPPORTED
:
137 return XEN_PCI_ERR_not_implemented
;
138 case PCIBIOS_SET_FAILED
:
139 return XEN_PCI_ERR_access_denied
;
144 int xen_pcibk_config_read(struct pci_dev
*dev
, int offset
, int size
,
148 struct xen_pcibk_dev_data
*dev_data
= pci_get_drvdata(dev
);
149 const struct config_field_entry
*cfg_entry
;
150 const struct config_field
*field
;
151 int req_start
, req_end
, field_start
, field_end
;
152 /* if read fails for any reason, return 0
153 * (as if device didn't respond) */
154 u32 value
= 0, tmp_val
;
156 if (unlikely(verbose_request
))
157 printk(KERN_DEBUG DRV_NAME
": %s: read %d bytes at 0x%x\n",
158 pci_name(dev
), size
, offset
);
160 if (!valid_request(offset
, size
)) {
161 err
= XEN_PCI_ERR_invalid_offset
;
165 /* Get the real value first, then modify as appropriate */
168 err
= pci_read_config_byte(dev
, offset
, (u8
*) &value
);
171 err
= pci_read_config_word(dev
, offset
, (u16
*) &value
);
174 err
= pci_read_config_dword(dev
, offset
, &value
);
178 list_for_each_entry(cfg_entry
, &dev_data
->config_fields
, list
) {
179 field
= cfg_entry
->field
;
182 req_end
= offset
+ size
;
183 field_start
= OFFSET(cfg_entry
);
184 field_end
= OFFSET(cfg_entry
) + field
->size
;
186 if (req_end
> field_start
&& field_end
> req_start
) {
187 err
= conf_space_read(dev
, cfg_entry
, field_start
,
192 value
= merge_value(value
, tmp_val
,
193 get_mask(field
->size
),
194 field_start
- req_start
);
199 if (unlikely(verbose_request
))
200 printk(KERN_DEBUG DRV_NAME
": %s: read %d bytes at 0x%x = %x\n",
201 pci_name(dev
), size
, offset
, value
);
204 return xen_pcibios_err_to_errno(err
);
207 int xen_pcibk_config_write(struct pci_dev
*dev
, int offset
, int size
, u32 value
)
209 int err
= 0, handled
= 0;
210 struct xen_pcibk_dev_data
*dev_data
= pci_get_drvdata(dev
);
211 const struct config_field_entry
*cfg_entry
;
212 const struct config_field
*field
;
214 int req_start
, req_end
, field_start
, field_end
;
216 if (unlikely(verbose_request
))
218 DRV_NAME
": %s: write request %d bytes at 0x%x = %x\n",
219 pci_name(dev
), size
, offset
, value
);
221 if (!valid_request(offset
, size
))
222 return XEN_PCI_ERR_invalid_offset
;
224 list_for_each_entry(cfg_entry
, &dev_data
->config_fields
, list
) {
225 field
= cfg_entry
->field
;
228 req_end
= offset
+ size
;
229 field_start
= OFFSET(cfg_entry
);
230 field_end
= OFFSET(cfg_entry
) + field
->size
;
232 if (req_end
> field_start
&& field_end
> req_start
) {
235 err
= xen_pcibk_config_read(dev
, field_start
,
236 field
->size
, &tmp_val
);
240 tmp_val
= merge_value(tmp_val
, value
, get_mask(size
),
241 req_start
- field_start
);
243 err
= conf_space_write(dev
, cfg_entry
, field_start
,
246 /* handled is set true here, but not every byte
247 * may have been written! Properly detecting if
248 * every byte is handled is unnecessary as the
249 * flag is used to detect devices that need
250 * special helpers to work correctly.
256 if (!handled
&& !err
) {
257 /* By default, anything not specificially handled above is
258 * read-only. The permissive flag changes this behavior so
259 * that anything not specifically handled above is writable.
260 * This means that some fields may still be read-only because
261 * they have entries in the config_field list that intercept
262 * the write and do nothing. */
263 if (dev_data
->permissive
|| xen_pcibk_permissive
) {
266 err
= pci_write_config_byte(dev
, offset
,
270 err
= pci_write_config_word(dev
, offset
,
274 err
= pci_write_config_dword(dev
, offset
,
278 } else if (!dev_data
->warned_on_write
) {
279 dev_data
->warned_on_write
= 1;
280 dev_warn(&dev
->dev
, "Driver tried to write to a "
281 "read-only configuration space field at offset"
282 " 0x%x, size %d. This may be harmless, but if "
283 "you have problems with your device:\n"
284 "1) see permissive attribute in sysfs\n"
285 "2) report problems to the xen-devel "
286 "mailing list along with details of your "
287 "device obtained from lspci.\n", offset
, size
);
291 return xen_pcibios_err_to_errno(err
);
294 void xen_pcibk_config_free_dyn_fields(struct pci_dev
*dev
)
296 struct xen_pcibk_dev_data
*dev_data
= pci_get_drvdata(dev
);
297 struct config_field_entry
*cfg_entry
, *t
;
298 const struct config_field
*field
;
300 dev_dbg(&dev
->dev
, "free-ing dynamically allocated virtual "
301 "configuration space fields\n");
305 list_for_each_entry_safe(cfg_entry
, t
, &dev_data
->config_fields
, list
) {
306 field
= cfg_entry
->field
;
309 field
->clean((struct config_field
*)field
);
311 kfree(cfg_entry
->data
);
313 list_del(&cfg_entry
->list
);
320 void xen_pcibk_config_reset_dev(struct pci_dev
*dev
)
322 struct xen_pcibk_dev_data
*dev_data
= pci_get_drvdata(dev
);
323 const struct config_field_entry
*cfg_entry
;
324 const struct config_field
*field
;
326 dev_dbg(&dev
->dev
, "resetting virtual configuration space\n");
330 list_for_each_entry(cfg_entry
, &dev_data
->config_fields
, list
) {
331 field
= cfg_entry
->field
;
334 field
->reset(dev
, OFFSET(cfg_entry
), cfg_entry
->data
);
338 void xen_pcibk_config_free_dev(struct pci_dev
*dev
)
340 struct xen_pcibk_dev_data
*dev_data
= pci_get_drvdata(dev
);
341 struct config_field_entry
*cfg_entry
, *t
;
342 const struct config_field
*field
;
344 dev_dbg(&dev
->dev
, "free-ing virtual configuration space fields\n");
348 list_for_each_entry_safe(cfg_entry
, t
, &dev_data
->config_fields
, list
) {
349 list_del(&cfg_entry
->list
);
351 field
= cfg_entry
->field
;
354 field
->release(dev
, OFFSET(cfg_entry
), cfg_entry
->data
);
360 int xen_pcibk_config_add_field_offset(struct pci_dev
*dev
,
361 const struct config_field
*field
,
362 unsigned int base_offset
)
365 struct xen_pcibk_dev_data
*dev_data
= pci_get_drvdata(dev
);
366 struct config_field_entry
*cfg_entry
;
369 cfg_entry
= kmalloc(sizeof(*cfg_entry
), GFP_KERNEL
);
375 cfg_entry
->data
= NULL
;
376 cfg_entry
->field
= field
;
377 cfg_entry
->base_offset
= base_offset
;
379 /* silently ignore duplicate fields */
380 err
= xen_pcibk_field_is_dup(dev
, OFFSET(cfg_entry
));
385 tmp
= field
->init(dev
, OFFSET(cfg_entry
));
392 cfg_entry
->data
= tmp
;
395 dev_dbg(&dev
->dev
, "added config field at offset 0x%02x\n",
397 list_add_tail(&cfg_entry
->list
, &dev_data
->config_fields
);
406 /* This sets up the device's virtual configuration space to keep track of
407 * certain registers (like the base address registers (BARs) so that we can
408 * keep the client from manipulating them directly.
410 int xen_pcibk_config_init_dev(struct pci_dev
*dev
)
413 struct xen_pcibk_dev_data
*dev_data
= pci_get_drvdata(dev
);
415 dev_dbg(&dev
->dev
, "initializing virtual configuration space\n");
417 INIT_LIST_HEAD(&dev_data
->config_fields
);
419 err
= xen_pcibk_config_header_add_fields(dev
);
423 err
= xen_pcibk_config_capability_add_fields(dev
);
427 err
= xen_pcibk_config_quirks_init(dev
);
433 int xen_pcibk_config_init(void)
435 return xen_pcibk_config_capability_init();