Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0 2 : : /* 3 : : * PCI ROM access routines 4 : : * 5 : : * (C) Copyright 2004 Jon Smirl <jonsmirl@yahoo.com> 6 : : * (C) Copyright 2004 Silicon Graphics, Inc. Jesse Barnes <jbarnes@sgi.com> 7 : : */ 8 : : #include <linux/kernel.h> 9 : : #include <linux/export.h> 10 : : #include <linux/pci.h> 11 : : #include <linux/slab.h> 12 : : 13 : : #include "pci.h" 14 : : 15 : : /** 16 : : * pci_enable_rom - enable ROM decoding for a PCI device 17 : : * @pdev: PCI device to enable 18 : : * 19 : : * Enable ROM decoding on @dev. This involves simply turning on the last 20 : : * bit of the PCI ROM BAR. Note that some cards may share address decoders 21 : : * between the ROM and other resources, so enabling it may disable access 22 : : * to MMIO registers or other card memory. 23 : : */ 24 : 0 : int pci_enable_rom(struct pci_dev *pdev) 25 : : { 26 : 0 : struct resource *res = &pdev->resource[PCI_ROM_RESOURCE]; 27 : 0 : struct pci_bus_region region; 28 : 0 : u32 rom_addr; 29 : : 30 [ # # ]: 0 : if (!res->flags) 31 : : return -1; 32 : : 33 : : /* Nothing to enable if we're using a shadow copy in RAM */ 34 [ # # ]: 0 : if (res->flags & IORESOURCE_ROM_SHADOW) 35 : : return 0; 36 : : 37 : : /* 38 : : * Ideally pci_update_resource() would update the ROM BAR address, 39 : : * and we would only set the enable bit here. But apparently some 40 : : * devices have buggy ROM BARs that read as zero when disabled. 41 : : */ 42 : 0 : pcibios_resource_to_bus(pdev->bus, ®ion, res); 43 : 0 : pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr); 44 : 0 : rom_addr &= ~PCI_ROM_ADDRESS_MASK; 45 : 0 : rom_addr |= region.start | PCI_ROM_ADDRESS_ENABLE; 46 : 0 : pci_write_config_dword(pdev, pdev->rom_base_reg, rom_addr); 47 : 0 : return 0; 48 : : } 49 : : EXPORT_SYMBOL_GPL(pci_enable_rom); 50 : : 51 : : /** 52 : : * pci_disable_rom - disable ROM decoding for a PCI device 53 : : * @pdev: PCI device to disable 54 : : * 55 : : * Disable ROM decoding on a PCI device by turning off the last bit in the 56 : : * ROM BAR. 57 : : */ 58 : 28 : void pci_disable_rom(struct pci_dev *pdev) 59 : : { 60 : 28 : struct resource *res = &pdev->resource[PCI_ROM_RESOURCE]; 61 : 28 : u32 rom_addr; 62 : : 63 [ - + ]: 28 : if (res->flags & IORESOURCE_ROM_SHADOW) 64 : 0 : return; 65 : : 66 : 28 : pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr); 67 : 28 : rom_addr &= ~PCI_ROM_ADDRESS_ENABLE; 68 : 28 : pci_write_config_dword(pdev, pdev->rom_base_reg, rom_addr); 69 : : } 70 : : EXPORT_SYMBOL_GPL(pci_disable_rom); 71 : : 72 : : /** 73 : : * pci_get_rom_size - obtain the actual size of the ROM image 74 : : * @pdev: target PCI device 75 : : * @rom: kernel virtual pointer to image of ROM 76 : : * @size: size of PCI window 77 : : * return: size of actual ROM image 78 : : * 79 : : * Determine the actual length of the ROM image. 80 : : * The PCI window size could be much larger than the 81 : : * actual image size. 82 : : */ 83 : 0 : static size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, 84 : : size_t size) 85 : : { 86 : 0 : void __iomem *image; 87 : 0 : int last_image; 88 : 0 : unsigned length; 89 : : 90 : 0 : image = rom; 91 : 0 : do { 92 : 0 : void __iomem *pds; 93 : : /* Standard PCI ROMs start out with these bytes 55 AA */ 94 [ # # ]: 0 : if (readw(image) != 0xAA55) { 95 : 0 : pci_info(pdev, "Invalid PCI ROM header signature: expecting 0xaa55, got %#06x\n", 96 : : readw(image)); 97 : 0 : break; 98 : : } 99 : : /* get the PCI data structure and check its "PCIR" signature */ 100 : 0 : pds = image + readw(image + 24); 101 [ # # ]: 0 : if (readl(pds) != 0x52494350) { 102 : 0 : pci_info(pdev, "Invalid PCI ROM data signature: expecting 0x52494350, got %#010x\n", 103 : : readl(pds)); 104 : 0 : break; 105 : : } 106 : 0 : last_image = readb(pds + 21) & 0x80; 107 : 0 : length = readw(pds + 16); 108 : 0 : image += length * 512; 109 : : /* Avoid iterating through memory outside the resource window */ 110 [ # # ]: 0 : if (image >= rom + size) 111 : : break; 112 [ # # ]: 0 : if (!last_image) { 113 [ # # ]: 0 : if (readw(image) != 0xAA55) { 114 : 0 : pci_info(pdev, "No more image in the PCI ROM\n"); 115 : 0 : break; 116 : : } 117 : : } 118 [ # # ]: 0 : } while (length && !last_image); 119 : : 120 : : /* never return a size larger than the PCI resource window */ 121 : : /* there are known ROMs that get the size wrong */ 122 : 0 : return min((size_t)(image - rom), size); 123 : : } 124 : : 125 : : /** 126 : : * pci_map_rom - map a PCI ROM to kernel space 127 : : * @pdev: pointer to pci device struct 128 : : * @size: pointer to receive size of pci window over ROM 129 : : * 130 : : * Return: kernel virtual pointer to image of ROM 131 : : * 132 : : * Map a PCI ROM into kernel space. If ROM is boot video ROM, 133 : : * the shadow BIOS copy will be returned instead of the 134 : : * actual ROM. 135 : : */ 136 : 0 : void __iomem *pci_map_rom(struct pci_dev *pdev, size_t *size) 137 : : { 138 : 0 : struct resource *res = &pdev->resource[PCI_ROM_RESOURCE]; 139 : 0 : loff_t start; 140 : 0 : void __iomem *rom; 141 : : 142 : : /* assign the ROM an address if it doesn't have one */ 143 [ # # # # ]: 0 : if (res->parent == NULL && pci_assign_resource(pdev, PCI_ROM_RESOURCE)) 144 : : return NULL; 145 : : 146 : 0 : start = pci_resource_start(pdev, PCI_ROM_RESOURCE); 147 [ # # # # ]: 0 : *size = pci_resource_len(pdev, PCI_ROM_RESOURCE); 148 [ # # ]: 0 : if (*size == 0) 149 : : return NULL; 150 : : 151 : : /* Enable ROM space decodes */ 152 [ # # ]: 0 : if (pci_enable_rom(pdev)) 153 : : return NULL; 154 : : 155 : 0 : rom = ioremap(start, *size); 156 [ # # ]: 0 : if (!rom) 157 : 0 : goto err_ioremap; 158 : : 159 : : /* 160 : : * Try to find the true size of the ROM since sometimes the PCI window 161 : : * size is much larger than the actual size of the ROM. 162 : : * True size is important if the ROM is going to be copied. 163 : : */ 164 : 0 : *size = pci_get_rom_size(pdev, rom, *size); 165 [ # # ]: 0 : if (!*size) 166 : 0 : goto invalid_rom; 167 : : 168 : : return rom; 169 : : 170 : : invalid_rom: 171 : 0 : iounmap(rom); 172 : 0 : err_ioremap: 173 : : /* restore enable if ioremap fails */ 174 [ # # ]: 0 : if (!(res->flags & IORESOURCE_ROM_ENABLE)) 175 : 0 : pci_disable_rom(pdev); 176 : : return NULL; 177 : : } 178 : : EXPORT_SYMBOL(pci_map_rom); 179 : : 180 : : /** 181 : : * pci_unmap_rom - unmap the ROM from kernel space 182 : : * @pdev: pointer to pci device struct 183 : : * @rom: virtual address of the previous mapping 184 : : * 185 : : * Remove a mapping of a previously mapped ROM 186 : : */ 187 : 0 : void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom) 188 : : { 189 : 0 : struct resource *res = &pdev->resource[PCI_ROM_RESOURCE]; 190 : : 191 : 0 : iounmap(rom); 192 : : 193 : : /* Disable again before continuing */ 194 [ # # ]: 0 : if (!(res->flags & IORESOURCE_ROM_ENABLE)) 195 : 0 : pci_disable_rom(pdev); 196 : 0 : } 197 : : EXPORT_SYMBOL(pci_unmap_rom); 198 : : 199 : : /** 200 : : * pci_platform_rom - provides a pointer to any ROM image provided by the 201 : : * platform 202 : : * @pdev: pointer to pci device struct 203 : : * @size: pointer to receive size of pci window over ROM 204 : : */ 205 : 0 : void __iomem *pci_platform_rom(struct pci_dev *pdev, size_t *size) 206 : : { 207 [ # # # # ]: 0 : if (pdev->rom && pdev->romlen) { 208 : 0 : *size = pdev->romlen; 209 : 0 : return phys_to_virt((phys_addr_t)pdev->rom); 210 : : } 211 : : 212 : : return NULL; 213 : : } 214 : : EXPORT_SYMBOL(pci_platform_rom);