blob: f955edb9bea7e801b186d2b431359dd0bf7d6047 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/pci/rom.c
3 *
4 * (C) Copyright 2004 Jon Smirl <jonsmirl@yahoo.com>
5 * (C) Copyright 2004 Silicon Graphics, Inc. Jesse Barnes <jbarnes@sgi.com>
6 *
7 * PCI ROM access routines
8 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/kernel.h>
Paul Gortmaker363c75d2011-05-27 09:37:25 -040010#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/pci.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080012#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013
14#include "pci.h"
15
16/**
17 * pci_enable_rom - enable ROM decoding for a PCI device
Martin Waitz67be2dd2005-05-01 08:59:26 -070018 * @pdev: PCI device to enable
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 *
20 * Enable ROM decoding on @dev. This involves simply turning on the last
21 * bit of the PCI ROM BAR. Note that some cards may share address decoders
22 * between the ROM and other resources, so enabling it may disable access
23 * to MMIO registers or other card memory.
24 */
Alan Coxe416de52008-09-23 17:25:10 +010025int pci_enable_rom(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070026{
Benjamin Herrenschmidt8085ce082005-08-31 14:16:53 +100027 struct resource *res = pdev->resource + PCI_ROM_RESOURCE;
28 struct pci_bus_region region;
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 u32 rom_addr;
30
Benjamin Herrenschmidt8085ce082005-08-31 14:16:53 +100031 if (!res->flags)
32 return -1;
33
Yinghai Lufc279852013-12-09 22:54:40 -080034 pcibios_resource_to_bus(pdev->bus, &region, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr);
Benjamin Herrenschmidt8085ce082005-08-31 14:16:53 +100036 rom_addr &= ~PCI_ROM_ADDRESS_MASK;
37 rom_addr |= region.start | PCI_ROM_ADDRESS_ENABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 pci_write_config_dword(pdev, pdev->rom_base_reg, rom_addr);
Benjamin Herrenschmidt8085ce082005-08-31 14:16:53 +100039 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040}
Ryan Desfossesb7fe9432014-04-25 14:32:25 -060041EXPORT_SYMBOL_GPL(pci_enable_rom);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43/**
44 * pci_disable_rom - disable ROM decoding for a PCI device
Martin Waitz67be2dd2005-05-01 08:59:26 -070045 * @pdev: PCI device to disable
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 *
47 * Disable ROM decoding on a PCI device by turning off the last bit in the
48 * ROM BAR.
49 */
Alan Coxe416de52008-09-23 17:25:10 +010050void pci_disable_rom(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051{
52 u32 rom_addr;
53 pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr);
54 rom_addr &= ~PCI_ROM_ADDRESS_ENABLE;
55 pci_write_config_dword(pdev, pdev->rom_base_reg, rom_addr);
56}
Ryan Desfossesb7fe9432014-04-25 14:32:25 -060057EXPORT_SYMBOL_GPL(pci_disable_rom);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
59/**
John Kellerd7ad2252007-07-09 11:42:24 -070060 * pci_get_rom_size - obtain the actual size of the ROM image
Randy Dunlap4cc59c72009-02-09 09:31:20 -080061 * @pdev: target PCI device
John Kellerd7ad2252007-07-09 11:42:24 -070062 * @rom: kernel virtual pointer to image of ROM
63 * @size: size of PCI window
64 * return: size of actual ROM image
65 *
66 * Determine the actual length of the ROM image.
67 * The PCI window size could be much larger than the
68 * actual image size.
69 */
Timothy S. Nelson97c44832009-01-30 06:12:47 +110070size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, size_t size)
John Kellerd7ad2252007-07-09 11:42:24 -070071{
72 void __iomem *image;
73 int last_image;
74
75 image = rom;
76 do {
77 void __iomem *pds;
78 /* Standard PCI ROMs start out with these bytes 55 AA */
Timothy S. Nelson97c44832009-01-30 06:12:47 +110079 if (readb(image) != 0x55) {
80 dev_err(&pdev->dev, "Invalid ROM contents\n");
John Kellerd7ad2252007-07-09 11:42:24 -070081 break;
Timothy S. Nelson97c44832009-01-30 06:12:47 +110082 }
John Kellerd7ad2252007-07-09 11:42:24 -070083 if (readb(image + 1) != 0xAA)
84 break;
85 /* get the PCI data structure and check its signature */
86 pds = image + readw(image + 24);
87 if (readb(pds) != 'P')
88 break;
89 if (readb(pds + 1) != 'C')
90 break;
91 if (readb(pds + 2) != 'I')
92 break;
93 if (readb(pds + 3) != 'R')
94 break;
95 last_image = readb(pds + 21) & 0x80;
96 /* this length is reliable */
97 image += readw(pds + 16) * 512;
98 } while (!last_image);
99
100 /* never return a size larger than the PCI resource window */
101 /* there are known ROMs that get the size wrong */
102 return min((size_t)(image - rom), size);
103}
104
105/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 * pci_map_rom - map a PCI ROM to kernel space
Martin Waitz67be2dd2005-05-01 08:59:26 -0700107 * @pdev: pointer to pci device struct
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 * @size: pointer to receive size of pci window over ROM
Randy Dunlapf5dafca2008-10-29 22:35:12 -0700109 *
110 * Return: kernel virtual pointer to image of ROM
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 *
112 * Map a PCI ROM into kernel space. If ROM is boot video ROM,
113 * the shadow BIOS copy will be returned instead of the
114 * actual ROM.
115 */
116void __iomem *pci_map_rom(struct pci_dev *pdev, size_t *size)
117{
118 struct resource *res = &pdev->resource[PCI_ROM_RESOURCE];
Matthew Garrettfffe01f2013-03-26 17:25:54 -0400119 loff_t start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 void __iomem *rom;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
eiichiro.oiwa.nm@hitachi.comb5e4efe2006-09-28 13:55:47 +0900122 /*
Eiichiro Oiwa6b5c76b2006-10-23 15:14:07 +0900123 * IORESOURCE_ROM_SHADOW set on x86, x86_64 and IA64 supports legacy
124 * memory map if the VGA enable bit of the Bridge Control register is
125 * set for embedded VGA.
eiichiro.oiwa.nm@hitachi.comb5e4efe2006-09-28 13:55:47 +0900126 */
Matthew Garrett547b5242013-03-19 17:26:57 -0400127 if (res->flags & IORESOURCE_ROM_SHADOW) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 /* primary video rom always starts here */
129 start = (loff_t)0xC0000;
130 *size = 0x20000; /* cover C000:0 through E000:0 */
131 } else {
John Kellera2302c62006-10-04 16:49:52 -0500132 if (res->flags &
133 (IORESOURCE_ROM_COPY | IORESOURCE_ROM_BIOS_COPY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 *size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
Greg Kroah-Hartmane31dd6e2006-06-12 17:06:02 -0700135 return (void __iomem *)(unsigned long)
136 pci_resource_start(pdev, PCI_ROM_RESOURCE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 } else {
Matthew Garrettfffe01f2013-03-26 17:25:54 -0400138 /* assign the ROM an address if it doesn't have one */
139 if (res->parent == NULL &&
Ryan Desfosses3c78bc62014-04-18 20:13:49 -0400140 pci_assign_resource(pdev, PCI_ROM_RESOURCE))
Matthew Garrettfffe01f2013-03-26 17:25:54 -0400141 return NULL;
142 start = pci_resource_start(pdev, PCI_ROM_RESOURCE);
143 *size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
144 if (*size == 0)
145 return NULL;
146
147 /* Enable ROM space decodes */
148 if (pci_enable_rom(pdev))
149 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 }
151 }
152
153 rom = ioremap(start, *size);
154 if (!rom) {
155 /* restore enable if ioremap fails */
156 if (!(res->flags & (IORESOURCE_ROM_ENABLE |
157 IORESOURCE_ROM_SHADOW |
158 IORESOURCE_ROM_COPY)))
159 pci_disable_rom(pdev);
160 return NULL;
161 }
162
163 /*
164 * Try to find the true size of the ROM since sometimes the PCI window
165 * size is much larger than the actual size of the ROM.
166 * True size is important if the ROM is going to be copied.
167 */
Timothy S. Nelson97c44832009-01-30 06:12:47 +1100168 *size = pci_get_rom_size(pdev, rom, *size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 return rom;
170}
Ryan Desfossesb7fe9432014-04-25 14:32:25 -0600171EXPORT_SYMBOL(pci_map_rom);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173/**
174 * pci_unmap_rom - unmap the ROM from kernel space
Martin Waitz67be2dd2005-05-01 08:59:26 -0700175 * @pdev: pointer to pci device struct
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 * @rom: virtual address of the previous mapping
177 *
178 * Remove a mapping of a previously mapped ROM
179 */
180void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom)
181{
182 struct resource *res = &pdev->resource[PCI_ROM_RESOURCE];
183
John Kellera2302c62006-10-04 16:49:52 -0500184 if (res->flags & (IORESOURCE_ROM_COPY | IORESOURCE_ROM_BIOS_COPY))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 return;
186
Matthew Garrettfffe01f2013-03-26 17:25:54 -0400187 iounmap(rom);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
189 /* Disable again before continuing, leave enabled if pci=rom */
190 if (!(res->flags & (IORESOURCE_ROM_ENABLE | IORESOURCE_ROM_SHADOW)))
191 pci_disable_rom(pdev);
192}
Ryan Desfossesb7fe9432014-04-25 14:32:25 -0600193EXPORT_SYMBOL(pci_unmap_rom);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195/**
Randy Dunlap06432452008-02-29 22:03:15 -0800196 * pci_cleanup_rom - free the ROM copy created by pci_map_rom_copy
Martin Waitz67be2dd2005-05-01 08:59:26 -0700197 * @pdev: pointer to pci device struct
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 *
199 * Free the copied ROM if we allocated one.
200 */
201void pci_cleanup_rom(struct pci_dev *pdev)
202{
203 struct resource *res = &pdev->resource[PCI_ROM_RESOURCE];
Bjorn Helgaasbd064f02014-02-26 11:25:58 -0700204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 if (res->flags & IORESOURCE_ROM_COPY) {
Ryan Desfosses3c78bc62014-04-18 20:13:49 -0400206 kfree((void *)(unsigned long)res->start);
Bjorn Helgaasbd064f02014-02-26 11:25:58 -0700207 res->flags |= IORESOURCE_UNSET;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 res->flags &= ~IORESOURCE_ROM_COPY;
209 res->start = 0;
210 res->end = 0;
211 }
212}
213
Matthew Garrettfffe01f2013-03-26 17:25:54 -0400214/**
215 * pci_platform_rom - provides a pointer to any ROM image provided by the
216 * platform
217 * @pdev: pointer to pci device struct
218 * @size: pointer to receive size of pci window over ROM
219 */
220void __iomem *pci_platform_rom(struct pci_dev *pdev, size_t *size)
221{
222 if (pdev->rom && pdev->romlen) {
223 *size = pdev->romlen;
224 return phys_to_virt((phys_addr_t)pdev->rom);
225 }
226
227 return NULL;
228}
Matthew Garrettfffe01f2013-03-26 17:25:54 -0400229EXPORT_SYMBOL(pci_platform_rom);