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