arch/x86/kernel/probe_roms.c

   1 #include <linux/sched.h>
   2 #include <linux/mm.h>
   3 #include <linux/uaccess.h>
   4 #include <linux/mmzone.h>
   5 #include <linux/ioport.h>
   6 #include <linux/seq_file.h>
   7 #include <linux/console.h>
   8 #include <linux/init.h>
   9 #include <linux/edd.h>
  10 #include <linux/dmi.h>
  11 #include <linux/pfn.h>
  12 #include <linux/pci.h>
  13 #include <linux/export.h>
  14
  15 #include <asm/probe_roms.h>
  16 #include <asm/pci-direct.h>
  17 #include <asm/e820.h>
  18 #include <asm/mmzone.h>
  19 #include <asm/setup.h>
  20 #include <asm/sections.h>
  21 #include <asm/io.h>
  22 #include <asm/setup_arch.h>
  23
  24 static struct resource system_rom_resource = {
  25         .name   = "System ROM",
  26         .start  = 0xf0000,
  27         .end    = 0xfffff,
  28         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  29 };
  30
  31 static struct resource extension_rom_resource = {
  32         .name   = "Extension ROM",
  33         .start  = 0xe0000,
  34         .end    = 0xeffff,
  35         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  36 };
  37
  38 static struct resource adapter_rom_resources[] = { {
  39         .name   = "Adapter ROM",
  40         .start  = 0xc8000,
  41         .end    = 0,
  42         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  43 }, {
  44         .name   = "Adapter ROM",
  45         .start  = 0,
  46         .end    = 0,
  47         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  48 }, {
  49         .name   = "Adapter ROM",
  50         .start  = 0,
  51         .end    = 0,
  52         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  53 }, {
  54         .name   = "Adapter ROM",
  55         .start  = 0,
  56         .end    = 0,
  57         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  58 }, {
  59         .name   = "Adapter ROM",
  60         .start  = 0,
  61         .end    = 0,
  62         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  63 }, {
  64         .name   = "Adapter ROM",
  65         .start  = 0,
  66         .end    = 0,
  67         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  68 } };
  69
  70 static struct resource video_rom_resource = {
  71         .name   = "Video ROM",
  72         .start  = 0xc0000,
  73         .end    = 0xc7fff,
  74         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
  75 };
  76
  77 /* does this oprom support the given pci device, or any of the devices
  78  * that the driver supports?
  79  */
  80 static bool match_id(struct pci_dev *pdev, unsigned short vendor, unsigned short device)
  81 {
  82         struct pci_driver *drv = pdev->driver;
  83         const struct pci_device_id *id;
  84
  85         if (pdev->vendor == vendor && pdev->device == device)
  86                 return true;
  87
  88         for (id = drv ? drv->id_table : NULL; id && id->vendor; id++)
  89                 if (id->vendor == vendor && id->device == device)
  90                         break;
  91
  92         return id && id->vendor;
  93 }
  94
  95 static bool probe_list(struct pci_dev *pdev, unsigned short vendor,
  96                        const unsigned char *rom_list)
  97 {
  98         unsigned short device;
  99
 100         do {
 101                 if (probe_kernel_address(rom_list, device) != 0)
 102                         device = 0;
 103
 104                 if (device && match_id(pdev, vendor, device))
 105                         break;
 106
 107                 rom_list += 2;
 108         } while (device);
 109
 110         return !!device;
 111 }
 112
 113 static struct resource *find_oprom(struct pci_dev *pdev)
 114 {
 115         struct resource *oprom = NULL;
 116         int i;
 117
 118         for (i = 0; i < ARRAY_SIZE(adapter_rom_resources); i++) {
 119                 struct resource *res = &adapter_rom_resources[i];
 120                 unsigned short offset, vendor, device, list, rev;
 121                 const unsigned char *rom;
 122
 123                 if (res->end == 0)
 124                         break;
 125
 126                 rom = isa_bus_to_virt(res->start);
 127                 if (probe_kernel_address(rom + 0x18, offset) != 0)
 128                         continue;
 129
 130                 if (probe_kernel_address(rom + offset + 0x4, vendor) != 0)
 131                         continue;
 132
 133                 if (probe_kernel_address(rom + offset + 0x6, device) != 0)
 134                         continue;
 135
 136                 if (match_id(pdev, vendor, device)) {
 137                         oprom = res;
 138                         break;
 139                 }
 140
 141                 if (probe_kernel_address(rom + offset + 0x8, list) == 0 &&
 142                     probe_kernel_address(rom + offset + 0xc, rev) == 0 &&
 143                     rev >= 3 && list &&
 144                     probe_list(pdev, vendor, rom + offset + list)) {
 145                         oprom = res;
 146                         break;
 147                 }
 148         }
 149
 150         return oprom;
 151 }
 152
 153 void __iomem *pci_map_biosrom(struct pci_dev *pdev)
 154 {
 155         struct resource *oprom = find_oprom(pdev);
 156
 157         if (!oprom)
 158                 return NULL;
 159
 160         return ioremap(oprom->start, resource_size(oprom));
 161 }
 162 EXPORT_SYMBOL(pci_map_biosrom);
 163
 164 void pci_unmap_biosrom(void __iomem *image)
 165 {
 166         iounmap(image);
 167 }
 168 EXPORT_SYMBOL(pci_unmap_biosrom);
 169
 170 size_t pci_biosrom_size(struct pci_dev *pdev)
 171 {
 172         struct resource *oprom = find_oprom(pdev);
 173
 174         return oprom ? resource_size(oprom) : 0;
 175 }
 176 EXPORT_SYMBOL(pci_biosrom_size);
 177
 178 #define ROMSIGNATURE 0xaa55
 179
 180 static int __init romsignature(const unsigned char *rom)
 181 {
 182         const unsigned short * const ptr = (const unsigned short *)rom;
 183         unsigned short sig;
 184
 185         return probe_kernel_address(ptr, sig) == 0 && sig == ROMSIGNATURE;
 186 }
 187
 188 static int __init romchecksum(const unsigned char *rom, unsigned long length)
 189 {
 190         unsigned char sum, c;
 191
 192         for (sum = 0; length && probe_kernel_address(rom++, c) == 0; length--)
 193                 sum += c;
 194         return !length && !sum;
 195 }
 196
 197 void __init probe_roms(void)
 198 {
 199         const unsigned char *rom;
 200         unsigned long start, length, upper;
 201         unsigned char c;
 202         int i;
 203
 204         /* video rom */
 205         upper = adapter_rom_resources[0].start;
 206         for (start = video_rom_resource.start; start < upper; start += 2048) {
 207                 rom = isa_bus_to_virt(start);
 208                 if (!romsignature(rom))
 209                         continue;
 210
 211                 video_rom_resource.start = start;
 212
 213                 if (probe_kernel_address(rom + 2, c) != 0)
 214                         continue;
 215
 216                 /* 0 < length <= 0x7f * 512, historically */
 217                 length = c * 512;
 218
 219                 /* if checksum okay, trust length byte */
 220                 if (length && romchecksum(rom, length))
 221                         video_rom_resource.end = start + length - 1;
 222
 223                 request_resource(&iomem_resource, &video_rom_resource);
 224                 break;
 225         }
 226
 227         start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
 228         if (start < upper)
 229                 start = upper;
 230
 231         /* system rom */
 232         request_resource(&iomem_resource, &system_rom_resource);
 233         upper = system_rom_resource.start;
 234
 235         /* check for extension rom (ignore length byte!) */
 236         rom = isa_bus_to_virt(extension_rom_resource.start);
 237         if (romsignature(rom)) {
 238                 length = resource_size(&extension_rom_resource);
 239                 if (romchecksum(rom, length)) {
 240                         request_resource(&iomem_resource, &extension_rom_resource);
 241                         upper = extension_rom_resource.start;
 242                 }
 243         }
 244
 245         /* check for adapter roms on 2k boundaries */
 246         for (i = 0; i < ARRAY_SIZE(adapter_rom_resources) && start < upper; start += 2048) {
 247                 rom = isa_bus_to_virt(start);
 248                 if (!romsignature(rom))
 249                         continue;
 250
 251                 if (probe_kernel_address(rom + 2, c) != 0)
 252                         continue;
 253
 254                 /* 0 < length <= 0x7f * 512, historically */
 255                 length = c * 512;
 256
 257                 /* but accept any length that fits if checksum okay */
 258                 if (!length || start + length > upper || !romchecksum(rom, length))
 259                         continue;
 260
 261                 adapter_rom_resources[i].start = start;
 262                 adapter_rom_resources[i].end = start + length - 1;
 263                 request_resource(&iomem_resource, &adapter_rom_resources[i]);
 264
 265                 start = adapter_rom_resources[i++].end & ~2047UL;
 266         }
 267 }
 268