1 #include <linux/pci.h> 2 #include <linux/module.h> 3 #include <linux/ioport.h> 4 5 #include "pci.h" 6 7 /* 8 * This interrupt-safe spinlock protects all accesses to PCI 9 * configuration space. 10 */ 11 12 static DEFINE_SPINLOCK(pci_lock); 13 14 /* 15 * Wrappers for all PCI configuration access functions. They just check 16 * alignment, do locking and call the low-level functions pointed to 17 * by pci_dev->ops. 18 */ 19 20 #define PCI_byte_BAD 0 21 #define PCI_word_BAD (pos & 1) 22 #define PCI_dword_BAD (pos & 3) 23 24 #define PCI_OP_READ(size,type,len) \ 25 int pci_bus_read_config_##size \ 26 (struct pci_bus *bus, unsigned int devfn, int pos, type *value) \ 27 { \ 28 int res; \ 29 unsigned long flags; \ 30 u32 data = 0; \ 31 if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER; \ 32 spin_lock_irqsave(&pci_lock, flags); \ 33 res = bus->ops->read(bus, devfn, pos, len, &data); \ 34 *value = (type)data; \ 35 spin_unlock_irqrestore(&pci_lock, flags); \ 36 return res; \ 37 } 38 39 #define PCI_OP_WRITE(size,type,len) \ 40 int pci_bus_write_config_##size \ 41 (struct pci_bus *bus, unsigned int devfn, int pos, type value) \ 42 { \ 43 int res; \ 44 unsigned long flags; \ 45 if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER; \ 46 spin_lock_irqsave(&pci_lock, flags); \ 47 res = bus->ops->write(bus, devfn, pos, len, value); \ 48 spin_unlock_irqrestore(&pci_lock, flags); \ 49 return res; \ 50 } 51 52 PCI_OP_READ(byte, u8, 1) 53 PCI_OP_READ(word, u16, 2) 54 PCI_OP_READ(dword, u32, 4) 55 PCI_OP_WRITE(byte, u8, 1) 56 PCI_OP_WRITE(word, u16, 2) 57 PCI_OP_WRITE(dword, u32, 4) 58 59 EXPORT_SYMBOL(pci_bus_read_config_byte); 60 EXPORT_SYMBOL(pci_bus_read_config_word); 61 EXPORT_SYMBOL(pci_bus_read_config_dword); 62 EXPORT_SYMBOL(pci_bus_write_config_byte); 63 EXPORT_SYMBOL(pci_bus_write_config_word); 64 EXPORT_SYMBOL(pci_bus_write_config_dword); 65 66 static u32 pci_user_cached_config(struct pci_dev *dev, int pos) 67 { 68 u32 data; 69 70 data = dev->saved_config_space[pos/sizeof(dev->saved_config_space[0])]; 71 data >>= (pos % sizeof(dev->saved_config_space[0])) * 8; 72 return data; 73 } 74 75 #define PCI_USER_READ_CONFIG(size,type) \ 76 int pci_user_read_config_##size \ 77 (struct pci_dev *dev, int pos, type *val) \ 78 { \ 79 unsigned long flags; \ 80 int ret = 0; \ 81 u32 data = -1; \ 82 if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER; \ 83 spin_lock_irqsave(&pci_lock, flags); \ 84 if (likely(!dev->block_ucfg_access)) \ 85 ret = dev->bus->ops->read(dev->bus, dev->devfn, \ 86 pos, sizeof(type), &data); \ 87 else if (pos < sizeof(dev->saved_config_space)) \ 88 data = pci_user_cached_config(dev, pos); \ 89 spin_unlock_irqrestore(&pci_lock, flags); \ 90 *val = (type)data; \ 91 return ret; \ 92 } 93 94 #define PCI_USER_WRITE_CONFIG(size,type) \ 95 int pci_user_write_config_##size \ 96 (struct pci_dev *dev, int pos, type val) \ 97 { \ 98 unsigned long flags; \ 99 int ret = -EIO; \ 100 if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER; \ 101 spin_lock_irqsave(&pci_lock, flags); \ 102 if (likely(!dev->block_ucfg_access)) \ 103 ret = dev->bus->ops->write(dev->bus, dev->devfn, \ 104 pos, sizeof(type), val); \ 105 spin_unlock_irqrestore(&pci_lock, flags); \ 106 return ret; \ 107 } 108 109 PCI_USER_READ_CONFIG(byte, u8) 110 PCI_USER_READ_CONFIG(word, u16) 111 PCI_USER_READ_CONFIG(dword, u32) 112 PCI_USER_WRITE_CONFIG(byte, u8) 113 PCI_USER_WRITE_CONFIG(word, u16) 114 PCI_USER_WRITE_CONFIG(dword, u32) 115 116 /** 117 * pci_block_user_cfg_access - Block userspace PCI config reads/writes 118 * @dev: pci device struct 119 * 120 * This function blocks any userspace PCI config accesses from occurring. 121 * When blocked, any writes will be bit bucketed and reads will return the 122 * data saved using pci_save_state for the first 64 bytes of config 123 * space and return 0xff for all other config reads. 124 **/ 125 void pci_block_user_cfg_access(struct pci_dev *dev) 126 { 127 unsigned long flags; 128 129 pci_save_state(dev); 130 131 /* spinlock to synchronize with anyone reading config space now */ 132 spin_lock_irqsave(&pci_lock, flags); 133 dev->block_ucfg_access = 1; 134 spin_unlock_irqrestore(&pci_lock, flags); 135 } 136 EXPORT_SYMBOL_GPL(pci_block_user_cfg_access); 137 138 /** 139 * pci_unblock_user_cfg_access - Unblock userspace PCI config reads/writes 140 * @dev: pci device struct 141 * 142 * This function allows userspace PCI config accesses to resume. 143 **/ 144 void pci_unblock_user_cfg_access(struct pci_dev *dev) 145 { 146 unsigned long flags; 147 148 /* spinlock to synchronize with anyone reading saved config space */ 149 spin_lock_irqsave(&pci_lock, flags); 150 dev->block_ucfg_access = 0; 151 spin_unlock_irqrestore(&pci_lock, flags); 152 } 153 EXPORT_SYMBOL_GPL(pci_unblock_user_cfg_access); 154