util/flashrom/chipset_enable.c

   1 /*
   2  * This file is part of the flashrom project.
   3  *
   4  * Copyright (C) 2000 Silicon Integrated System Corporation
   5  * Copyright (C) 2005-2007 coresystems GmbH <stepan@coresystems.de>
   6  * Copyright (C) 2006 Uwe Hermann <uwe@hermann-uwe.de>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; version 2 of the License.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  20  */
  21
  22 /*
  23  * Contains the chipset specific flash enables.
  24  */
  25
  26 #define _LARGEFILE64_SOURCE
  27
  28 #include <stdio.h>
  29 #include <pci/pci.h>
  30 #include <stdlib.h>
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <sys/mman.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include "flash.h"
  37
  38 /**
  39  * flashrom defaults to LPC flash devices. If a known SPI controller is found
  40  * and the SPI strappings are set, this will be overwritten by the probing code.
  41  *
  42  * Eventually, this will become an array when multiple flash support works.
  43  */
  44
  45 flashbus_t flashbus = BUS_TYPE_LPC;
  46 void *spibar = NULL;
  47
  48 static int enable_flash_ali_m1533(struct pci_dev *dev, const char *name)
  49 {
  50         uint8_t tmp;
  51
  52         /*
  53          * ROM Write enable, 0xFFFC0000-0xFFFDFFFF and
  54          * 0xFFFE0000-0xFFFFFFFF ROM select enable.
  55          */
  56         tmp = pci_read_byte(dev, 0x47);
  57         tmp |= 0x46;
  58         pci_write_byte(dev, 0x47, tmp);
  59
  60         return 0;
  61 }
  62
  63 static int enable_flash_sis630(struct pci_dev *dev, const char *name)
  64 {
  65         uint8_t b;
  66
  67         /* Enable 0xFFF8000~0xFFFF0000 decoding on SiS 540/630. */
  68         b = pci_read_byte(dev, 0x40);
  69         pci_write_byte(dev, 0x40, b | 0xb);
  70
  71         /* Flash write enable on SiS 540/630. */
  72         b = pci_read_byte(dev, 0x45);
  73         pci_write_byte(dev, 0x45, b | 0x40);
  74
  75         /* The same thing on SiS 950 Super I/O side... */
  76
  77         /* First probe for Super I/O on config port 0x2e. */
  78         OUTB(0x87, 0x2e);
  79         OUTB(0x01, 0x2e);
  80         OUTB(0x55, 0x2e);
  81         OUTB(0x55, 0x2e);
  82
  83         if (INB(0x2f) != 0x87) {
  84                 /* If that failed, try config port 0x4e. */
  85                 OUTB(0x87, 0x4e);
  86                 OUTB(0x01, 0x4e);
  87                 OUTB(0x55, 0x4e);
  88                 OUTB(0xaa, 0x4e);
  89                 if (INB(0x4f) != 0x87) {
  90                         printf("Can not access SiS 950\n");
  91                         return -1;
  92                 }
  93                 OUTB(0x24, 0x4e);
  94                 b = INB(0x4f) | 0xfc;
  95                 OUTB(0x24, 0x4e);
  96                 OUTB(b, 0x4f);
  97                 OUTB(0x02, 0x4e);
  98                 OUTB(0x02, 0x4f);
  99         }
 100
 101         OUTB(0x24, 0x2e);
 102         printf("2f is %#x\n", INB(0x2f));
 103         b = INB(0x2f) | 0xfc;
 104         OUTB(0x24, 0x2e);
 105         OUTB(b, 0x2f);
 106
 107         OUTB(0x02, 0x2e);
 108         OUTB(0x02, 0x2f);
 109
 110         return 0;
 111 }
 112
 113 /* Datasheet:
 114  *   - Name: 82371AB PCI-TO-ISA / IDE XCELERATOR (PIIX4)
 115  *   - URL: http://www.intel.com/design/intarch/datashts/290562.htm
 116  *   - PDF: http://www.intel.com/design/intarch/datashts/29056201.pdf
 117  *   - Order Number: 290562-001
 118  */
 119 static int enable_flash_piix4(struct pci_dev *dev, const char *name)
 120 {
 121         uint16_t old, new;
 122         uint16_t xbcs = 0x4e;   /* X-Bus Chip Select register. */
 123
 124         old = pci_read_word(dev, xbcs);
 125
 126         /* Set bit 9: 1-Meg Extended BIOS Enable (PCI master accesses to
 127          *            FFF00000-FFF7FFFF are forwarded to ISA).
 128          *            Note: This bit is reserved on PIIX/PIIX3/MPIIX.
 129          * Set bit 7: Extended BIOS Enable (PCI master accesses to
 130          *            FFF80000-FFFDFFFF are forwarded to ISA).
 131          * Set bit 6: Lower BIOS Enable (PCI master, or ISA master accesses to
 132          *            the lower 64-Kbyte BIOS block (E0000-EFFFF) at the top
 133          *            of 1 Mbyte, or the aliases at the top of 4 Gbyte
 134          *            (FFFE0000-FFFEFFFF) result in the generation of BIOSCS#.
 135          * Note: Accesses to FFFF0000-FFFFFFFF are always forwarded to ISA.
 136          * Set bit 2: BIOSCS# Write Enable (1=enable, 0=disable).
 137          */
 138         if (dev->device_id == 0x122e || dev->device_id == 0x7000
 139             || dev->device_id == 0x1234)
 140                 new = old | 0x00c4; /* PIIX/PIIX3/MPIIX: Bit 9 is reserved. */
 141         else
 142                 new = old | 0x02c4;
 143
 144         if (new == old)
 145                 return 0;
 146
 147         pci_write_word(dev, xbcs, new);
 148
 149         if (pci_read_word(dev, xbcs) != new) {
 150                 printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", xbcs, new, name);
 151                 return -1;
 152         }
 153
 154         return 0;
 155 }
 156
 157 /*
 158  * See ie. page 375 of "Intel I/O Controller Hub 7 (ICH7) Family Datasheet"
 159  * http://download.intel.com/design/chipsets/datashts/30701303.pdf
 160  */
 161 static int enable_flash_ich(struct pci_dev *dev, const char *name,
 162                             int bios_cntl)
 163 {
 164         uint8_t old, new;
 165
 166         /*
 167          * Note: the ICH0-ICH5 BIOS_CNTL register is actually 16 bit wide, but
 168          * just treating it as 8 bit wide seems to work fine in practice.
 169          */
 170         old = pci_read_byte(dev, bios_cntl);
 171
 172         printf_debug("\nBIOS Lock Enable: %sabled, ",
 173                      (old & (1 << 1)) ? "en" : "dis");
 174         printf_debug("BIOS Write Enable: %sabled, ",
 175                      (old & (1 << 0)) ? "en" : "dis");
 176         printf_debug("BIOS_CNTL is 0x%x\n", old);
 177
 178         new = old | 1;
 179
 180         if (new == old)
 181                 return 0;
 182
 183         pci_write_byte(dev, bios_cntl, new);
 184
 185         if (pci_read_byte(dev, bios_cntl) != new) {
 186                 printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", bios_cntl, new, name);
 187                 return -1;
 188         }
 189
 190         return 0;
 191 }
 192
 193 static int enable_flash_ich_4e(struct pci_dev *dev, const char *name)
 194 {
 195         return enable_flash_ich(dev, name, 0x4e);
 196 }
 197
 198 static int enable_flash_ich_dc(struct pci_dev *dev, const char *name)
 199 {
 200         return enable_flash_ich(dev, name, 0xdc);
 201 }
 202
 203 #define ICH_STRAP_RSVD 0x00
 204 #define ICH_STRAP_SPI  0x01
 205 #define ICH_STRAP_PCI  0x02
 206 #define ICH_STRAP_LPC  0x03
 207
 208 static int enable_flash_vt8237s_spi(struct pci_dev *dev, const char *name)
 209 {
 210         uint32_t mmio_base;
 211
 212         mmio_base = (pci_read_long(dev, 0xbc)) << 8;
 213         printf_debug("MMIO base at = 0x%x\n", mmio_base);
 214         spibar = mmap(NULL, 0x70, PROT_READ | PROT_WRITE, MAP_SHARED,
 215                       fd_mem, mmio_base);
 216
 217         if (spibar == MAP_FAILED) {
 218                 perror("Can't mmap memory using " MEM_DEV);
 219                 exit(1);
 220         }
 221
 222         printf_debug("0x6c: 0x%04x     (CLOCK/DEBUG)\n",
 223                      *(uint16_t *) (spibar + 0x6c));
 224
 225         flashbus = BUS_TYPE_VIA_SPI;
 226
 227         return 0;
 228 }
 229
 230 static int enable_flash_ich_dc_spi(struct pci_dev *dev, const char *name,
 231                                    int ich_generation)
 232 {
 233         int ret, i;
 234         uint8_t old, new, bbs, buc;
 235         uint16_t spibar_offset, tmp2;
 236         uint32_t tmp, gcs;
 237         void *rcrb;
 238         //TODO: These names are incorrect for EP80579. For that, the solution would look like the commented line
 239         //static const char *straps_names[] = {"SPI", "reserved", "reserved", "LPC" };
 240         static const char *straps_names[] = { "reserved", "SPI", "PCI", "LPC" };
 241
 242         /* Enable Flash Writes */
 243         ret = enable_flash_ich_dc(dev, name);
 244
 245         /* Get physical address of Root Complex Register Block */
 246         tmp = pci_read_long(dev, 0xf0) & 0xffffc000;
 247         printf_debug("\nRoot Complex Register Block address = 0x%x\n", tmp);
 248
 249         /* Map RCBA to virtual memory */
 250         rcrb = mmap(0, 0x4000, PROT_READ | PROT_WRITE, MAP_SHARED, fd_mem,
 251                     (off_t) tmp);
 252         if (rcrb == MAP_FAILED) {
 253                 perror("Can't mmap memory using " MEM_DEV);
 254                 exit(1);
 255         }
 256
 257         gcs = *(volatile uint32_t *)(rcrb + 0x3410);
 258         printf_debug("GCS = 0x%x: ", gcs);
 259         printf_debug("BIOS Interface Lock-Down: %sabled, ",
 260                      (gcs & 0x1) ? "en" : "dis");
 261         bbs = (gcs >> 10) & 0x3;
 262         printf_debug("BOOT BIOS Straps: 0x%x (%s)\n", bbs, straps_names[bbs]);
 263
 264         buc = *(volatile uint8_t *)(rcrb + 0x3414);
 265         printf_debug("Top Swap : %s\n",
 266                      (buc & 1) ? "enabled (A16 inverted)" : "not enabled");
 267
 268         /* It seems the ICH7 does not support SPI and LPC chips at the same
 269          * time. At least not with our current code. So we prevent searching
 270          * on ICH7 when the southbridge is strapped to LPC
 271          */
 272
 273         if (ich_generation == 7 && bbs == ICH_STRAP_LPC) {
 274                 /* No further SPI initialization required */
 275                 return ret;
 276         }
 277
 278         switch (ich_generation) {
 279         case 7:
 280                 flashbus = BUS_TYPE_ICH7_SPI;
 281                 spibar_offset = 0x3020;
 282                 break;
 283         case 8:
 284                 flashbus = BUS_TYPE_ICH9_SPI;
 285                 spibar_offset = 0x3020;
 286                 break;
 287         case 9:
 288         case 10:
 289         default:                /* Future version might behave the same */
 290                 flashbus = BUS_TYPE_ICH9_SPI;
 291                 spibar_offset = 0x3800;
 292                 break;
 293         }
 294
 295         /* SPIBAR is at RCRB+0x3020 for ICH[78] and RCRB+0x3800 for ICH9. */
 296         printf_debug("SPIBAR = 0x%x + 0x%04x\n", tmp, spibar_offset);
 297
 298         /* Assign Virtual Address */
 299         spibar = rcrb + spibar_offset;
 300
 301         switch (flashbus) {
 302         case BUS_TYPE_ICH7_SPI:
 303                 printf_debug("0x00: 0x%04x     (SPIS)\n",
 304                              *(uint16_t *) (spibar + 0));
 305                 printf_debug("0x02: 0x%04x     (SPIC)\n",
 306                              *(uint16_t *) (spibar + 2));
 307                 printf_debug("0x04: 0x%08x (SPIA)\n",
 308                              *(uint32_t *) (spibar + 4));
 309                 for (i = 0; i < 8; i++) {
 310                         int offs;
 311                         offs = 8 + (i * 8);
 312                         printf_debug("0x%02x: 0x%08x (SPID%d)\n", offs,
 313                                      *(uint32_t *) (spibar + offs), i);
 314                         printf_debug("0x%02x: 0x%08x (SPID%d+4)\n", offs + 4,
 315                                      *(uint32_t *) (spibar + offs + 4), i);
 316                 }
 317                 printf_debug("0x50: 0x%08x (BBAR)\n",
 318                              *(uint32_t *) (spibar + 0x50));
 319                 printf_debug("0x54: 0x%04x     (PREOP)\n",
 320                              *(uint16_t *) (spibar + 0x54));
 321                 printf_debug("0x56: 0x%04x     (OPTYPE)\n",
 322                              *(uint16_t *) (spibar + 0x56));
 323                 printf_debug("0x58: 0x%08x (OPMENU)\n",
 324                              *(uint32_t *) (spibar + 0x58));
 325                 printf_debug("0x5c: 0x%08x (OPMENU+4)\n",
 326                              *(uint32_t *) (spibar + 0x5c));
 327                 for (i = 0; i < 4; i++) {
 328                         int offs;
 329                         offs = 0x60 + (i * 4);
 330                         printf_debug("0x%02x: 0x%08x (PBR%d)\n", offs,
 331                                      *(uint32_t *) (spibar + offs), i);
 332                 }
 333                 printf_debug("\n");
 334                 if ((*(uint16_t *) spibar) & (1 << 15)) {
 335                         printf("WARNING: SPI Configuration Lockdown activated.\n");
 336                 }
 337                 break;
 338         case BUS_TYPE_ICH9_SPI:
 339                 tmp2 = *(uint16_t *) (spibar + 0);
 340                 printf_debug("0x00: 0x%04x (HSFS)\n", tmp2);
 341                 printf_debug("FLOCKDN %i, ", (tmp >> 15 & 1));
 342                 printf_debug("FDV %i, ", (tmp >> 14) & 1);
 343                 printf_debug("FDOPSS %i, ", (tmp >> 13) & 1);
 344                 printf_debug("SCIP %i, ", (tmp >> 5) & 1);
 345                 printf_debug("BERASE %i, ", (tmp >> 3) & 3);
 346                 printf_debug("AEL %i, ", (tmp >> 2) & 1);
 347                 printf_debug("FCERR %i, ", (tmp >> 1) & 1);
 348                 printf_debug("FDONE %i\n", (tmp >> 0) & 1);
 349
 350                 tmp = *(uint32_t *) (spibar + 0x50);
 351                 printf_debug("0x50: 0x%08x (FRAP)\n", tmp);
 352                 printf_debug("BMWAG %i, ", (tmp >> 24) & 0xff);
 353                 printf_debug("BMRAG %i, ", (tmp >> 16) & 0xff);
 354                 printf_debug("BRWA %i, ", (tmp >> 8) & 0xff);
 355                 printf_debug("BRRA %i\n", (tmp >> 0) & 0xff);
 356
 357                 printf_debug("0x54: 0x%08x (FREG0)\n",
 358                              *(uint32_t *) (spibar + 0x54));
 359                 printf_debug("0x58: 0x%08x (FREG1)\n",
 360                              *(uint32_t *) (spibar + 0x58));
 361                 printf_debug("0x5C: 0x%08x (FREG2)\n",
 362                              *(uint32_t *) (spibar + 0x5C));
 363                 printf_debug("0x60: 0x%08x (FREG3)\n",
 364                              *(uint32_t *) (spibar + 0x60));
 365                 printf_debug("0x64: 0x%08x (FREG4)\n",
 366                              *(uint32_t *) (spibar + 0x64));
 367                 printf_debug("0x74: 0x%08x (PR0)\n",
 368                              *(uint32_t *) (spibar + 0x74));
 369                 printf_debug("0x78: 0x%08x (PR1)\n",
 370                              *(uint32_t *) (spibar + 0x78));
 371                 printf_debug("0x7C: 0x%08x (PR2)\n",
 372                              *(uint32_t *) (spibar + 0x7C));
 373                 printf_debug("0x80: 0x%08x (PR3)\n",
 374                              *(uint32_t *) (spibar + 0x80));
 375                 printf_debug("0x84: 0x%08x (PR4)\n",
 376                              *(uint32_t *) (spibar + 0x84));
 377                 /* printf_debug("0xA0: 0x%08x (BBAR)\n",
 378                              *(uint32_t *) (spibar + 0xA0)); ICH10 only? */
 379                 printf_debug("0xB0: 0x%08x (FDOC)\n",
 380                              *(uint32_t *) (spibar + 0xB0));
 381                 break;
 382         default:
 383                 /* Nothing */
 384                 break;
 385         }
 386
 387         old = pci_read_byte(dev, 0xdc);
 388         printf_debug("SPI Read Configuration: ");
 389         new = (old >> 2) & 0x3;
 390         switch (new) {
 391         case 0:
 392         case 1:
 393         case 2:
 394                 printf_debug("prefetching %sabled, caching %sabled, ",
 395                              (new & 0x2) ? "en" : "dis",
 396                              (new & 0x1) ? "dis" : "en");
 397                 break;
 398         default:
 399                 printf_debug("invalid prefetching/caching settings, ");
 400                 break;
 401         }
 402
 403         return ret;
 404 }
 405
 406 static int enable_flash_ich7(struct pci_dev *dev, const char *name)
 407 {
 408         return enable_flash_ich_dc_spi(dev, name, 7);
 409 }
 410
 411 static int enable_flash_ich8(struct pci_dev *dev, const char *name)
 412 {
 413         return enable_flash_ich_dc_spi(dev, name, 8);
 414 }
 415
 416 static int enable_flash_ich9(struct pci_dev *dev, const char *name)
 417 {
 418         return enable_flash_ich_dc_spi(dev, name, 9);
 419 }
 420
 421 static int enable_flash_ich10(struct pci_dev *dev, const char *name)
 422 {
 423         return enable_flash_ich_dc_spi(dev, name, 10);
 424 }
 425
 426 static int enable_flash_vt823x(struct pci_dev *dev, const char *name)
 427 {
 428         uint8_t val;
 429
 430         /* enable ROM decode range (1MB) FFC00000 - FFFFFFFF */
 431         pci_write_byte(dev, 0x41, 0x7f);
 432
 433         /* ROM write enable */
 434         val = pci_read_byte(dev, 0x40);
 435         val |= 0x10;
 436         pci_write_byte(dev, 0x40, val);
 437
 438         if (pci_read_byte(dev, 0x40) != val) {
 439                 printf("\nWARNING: Failed to enable ROM Write on \"%s\"\n",
 440                        name);
 441                 return -1;
 442         }
 443
 444         return 0;
 445 }
 446
 447 static int enable_flash_cs5530(struct pci_dev *dev, const char *name)
 448 {
 449         uint8_t reg8;
 450
 451 #define DECODE_CONTROL_REG2             0x5b    /* F0 index 0x5b */
 452 #define ROM_AT_LOGIC_CONTROL_REG        0x52    /* F0 index 0x52 */
 453
 454 #define LOWER_ROM_ADDRESS_RANGE         (1 << 0)
 455 #define ROM_WRITE_ENABLE                (1 << 1)
 456 #define UPPER_ROM_ADDRESS_RANGE         (1 << 2)
 457 #define BIOS_ROM_POSITIVE_DECODE        (1 << 5)
 458
 459         /* Decode 0x000E0000-0x000FFFFF (128 KB), not just 64 KB, and
 460          * decode 0xFF000000-0xFFFFFFFF (16 MB), not just 256 KB.
 461          * Make the configured ROM areas writable.
 462          */
 463         reg8 = pci_read_byte(dev, ROM_AT_LOGIC_CONTROL_REG);
 464         reg8 |= LOWER_ROM_ADDRESS_RANGE;
 465         reg8 |= UPPER_ROM_ADDRESS_RANGE;
 466         reg8 |= ROM_WRITE_ENABLE;
 467         pci_write_byte(dev, ROM_AT_LOGIC_CONTROL_REG, reg8);
 468
 469         /* Set positive decode on ROM. */
 470         reg8 = pci_read_byte(dev, DECODE_CONTROL_REG2);
 471         reg8 |= BIOS_ROM_POSITIVE_DECODE;
 472         pci_write_byte(dev, DECODE_CONTROL_REG2, reg8);
 473
 474         return 0;
 475 }
 476
 477 /**
 478  * Geode systems write protect the BIOS via RCONFs (cache settings similar
 479  * to MTRRs). To unlock, change MSR 0x1808 top byte to 0x22. Reading and
 480  * writing to MSRs, however requires instructions rdmsr/wrmsr, which are
 481  * ring0 privileged instructions so only the kernel can do the read/write.
 482  * This function, therefore, requires that the msr kernel module be loaded
 483  * to access these instructions from user space using device /dev/cpu/0/msr.
 484  *
 485  * This hard-coded location could have potential problems on SMP machines
 486  * since it assumes cpu0, but it is safe on the Geode which is not SMP.
 487  *
 488  * Geode systems also write protect the NOR flash chip itself via MSR_NORF_CTL.
 489  * To enable write to NOR Boot flash for the benefit of systems that have such
 490  * a setup, raise MSR 0x51400018 WE_CS3 (write enable Boot Flash Chip Select).
 491  *
 492  * This is probably not portable beyond Linux.
 493  */
 494 static int enable_flash_cs5536(struct pci_dev *dev, const char *name)
 495 {
 496 #define MSR_RCONF_DEFAULT       0x1808
 497 #define MSR_NORF_CTL            0x51400018
 498
 499         int fd_msr;
 500         unsigned char buf[8];
 501
 502         fd_msr = open("/dev/cpu/0/msr", O_RDWR);
 503         if (!fd_msr) {
 504                 perror("open msr");
 505                 return -1;
 506         }
 507
 508         if (lseek64(fd_msr, (off64_t) MSR_RCONF_DEFAULT, SEEK_SET) == -1) {
 509                 perror("lseek64");
 510                 printf("Cannot operate on MSR. Did you run 'modprobe msr'?\n");
 511                 close(fd_msr);
 512                 return -1;
 513         }
 514
 515         if (read(fd_msr, buf, 8) != 8) {
 516                 perror("read msr");
 517                 close(fd_msr);
 518                 return -1;
 519         }
 520
 521         if (buf[7] != 0x22) {
 522                 buf[7] &= 0xfb;
 523                 if (lseek64(fd_msr, (off64_t) MSR_RCONF_DEFAULT,
 524                             SEEK_SET) == -1) {
 525                         perror("lseek64");
 526                         close(fd_msr);
 527                         return -1;
 528                 }
 529
 530                 if (write(fd_msr, buf, 8) < 0) {
 531                         perror("msr write");
 532                         close(fd_msr);
 533                         return -1;
 534                 }
 535         }
 536
 537         if (lseek64(fd_msr, (off64_t) MSR_NORF_CTL, SEEK_SET) == -1) {
 538                 perror("lseek64");
 539                 close(fd_msr);
 540                 return -1;
 541         }
 542
 543         if (read(fd_msr, buf, 8) != 8) {
 544                 perror("read msr");
 545                 close(fd_msr);
 546                 return -1;
 547         }
 548
 549         /* Raise WE_CS3 bit. */
 550         buf[0] |= 0x08;
 551
 552         if (lseek64(fd_msr, (off64_t) MSR_NORF_CTL, SEEK_SET) == -1) {
 553                 perror("lseek64");
 554                 close(fd_msr);
 555                 return -1;
 556         }
 557         if (write(fd_msr, buf, 8) < 0) {
 558                 perror("msr write");
 559                 close(fd_msr);
 560                 return -1;
 561         }
 562
 563         close(fd_msr);
 564
 565 #undef MSR_RCONF_DEFAULT
 566 #undef MSR_NORF_CTL
 567         return 0;
 568 }
 569
 570 static int enable_flash_sc1100(struct pci_dev *dev, const char *name)
 571 {
 572         uint8_t new;
 573
 574         pci_write_byte(dev, 0x52, 0xee);
 575
 576         new = pci_read_byte(dev, 0x52);
 577
 578         if (new != 0xee) {
 579                 printf("tried to set register 0x%x to 0x%x on %s failed (WARNING ONLY)\n", 0x52, new, name);
 580                 return -1;
 581         }
 582
 583         return 0;
 584 }
 585
 586 static int enable_flash_sis5595(struct pci_dev *dev, const char *name)
 587 {
 588         uint8_t new, newer;
 589
 590         new = pci_read_byte(dev, 0x45);
 591
 592         new &= (~0x20);         /* Clear bit 5. */
 593         new |= 0x4;             /* Set bit 2. */
 594
 595         pci_write_byte(dev, 0x45, new);
 596
 597         newer = pci_read_byte(dev, 0x45);
 598         if (newer != new) {
 599                 printf("tried to set register 0x%x to 0x%x on %s failed (WARNING ONLY)\n", 0x45, new, name);
 600                 printf("Stuck at 0x%x\n", newer);
 601                 return -1;
 602         }
 603
 604         /* Extended BIOS enable = 1, Lower BIOS Enable = 1 */
 605         new = pci_read_byte(dev, 0x40);
 606         new &= 0xFB;
 607         new |= 0x3;
 608         pci_write_byte(dev, 0x40, new);
 609         newer = pci_read_byte(dev, 0x40);
 610         if (newer != new) {
 611                 printf("tried to set register 0x%x to 0x%x on %s failed (WARNING ONLY)\n", 0x40, new, name);
 612                 printf("Stuck at 0x%x\n", newer);
 613                 return -1;
 614         }
 615         return 0;
 616 }
 617
 618 /* Works for AMD-8111, VIA VT82C586A/B, VIA VT82C686A/B. */
 619 static int enable_flash_amd8111(struct pci_dev *dev, const char *name)
 620 {
 621         uint8_t old, new;
 622
 623         /* Enable decoding at 0xffb00000 to 0xffffffff. */
 624         old = pci_read_byte(dev, 0x43);
 625         new = old | 0xC0;
 626         if (new != old) {
 627                 pci_write_byte(dev, 0x43, new);
 628                 if (pci_read_byte(dev, 0x43) != new) {
 629                         printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", 0x43, new, name);
 630                 }
 631         }
 632
 633         /* Enable 'ROM write' bit. */
 634         old = pci_read_byte(dev, 0x40);
 635         new = old | 0x01;
 636         if (new == old)
 637                 return 0;
 638         pci_write_byte(dev, 0x40, new);
 639
 640         if (pci_read_byte(dev, 0x40) != new) {
 641                 printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", 0x40, new, name);
 642                 return -1;
 643         }
 644
 645         return 0;
 646 }
 647
 648 static int enable_flash_sb600(struct pci_dev *dev, const char *name)
 649 {
 650         uint32_t old, new;
 651         uint8_t reg;
 652
 653         /* Clear ROM Protect 0-3 */
 654         for (reg = 0x50; reg < 0x60; reg += 4) {
 655                 old = pci_read_long(dev, reg);
 656                 new = old & 0xFFFFFFFC;
 657                 if (new != old) {
 658                         pci_write_byte(dev, reg, new);
 659                         if (pci_read_long(dev, reg) != new) {
 660                                 printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", 0x50, new, name);
 661                         }
 662                 }
 663         }
 664
 665         return 0;
 666 }
 667
 668 static int enable_flash_ck804(struct pci_dev *dev, const char *name)
 669 {
 670         uint8_t old, new;
 671
 672         old = pci_read_byte(dev, 0x88);
 673         new = old | 0xc0;
 674         if (new != old) {
 675                 pci_write_byte(dev, 0x88, new);
 676                 if (pci_read_byte(dev, 0x88) != new) {
 677                         printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", 0x88, new, name);
 678                 }
 679         }
 680
 681         old = pci_read_byte(dev, 0x6d);
 682         new = old | 0x01;
 683         if (new == old)
 684                 return 0;
 685         pci_write_byte(dev, 0x6d, new);
 686
 687         if (pci_read_byte(dev, 0x6d) != new) {
 688                 printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", 0x6d, new, name);
 689                 return -1;
 690         }
 691
 692         return 0;
 693 }
 694
 695 /* ATI Technologies Inc IXP SB400 PCI-ISA Bridge (rev 80) */
 696 static int enable_flash_sb400(struct pci_dev *dev, const char *name)
 697 {
 698         uint8_t tmp;
 699         struct pci_filter f;
 700         struct pci_dev *smbusdev;
 701
 702         /* Look for the SMBus device. */
 703         pci_filter_init((struct pci_access *)0, &f);
 704         f.vendor = 0x1002;
 705         f.device = 0x4372;
 706
 707         for (smbusdev = pacc->devices; smbusdev; smbusdev = smbusdev->next) {
 708                 if (pci_filter_match(&f, smbusdev))
 709                         break;
 710         }
 711
 712         if (!smbusdev) {
 713                 fprintf(stderr, "ERROR: SMBus device not found. Aborting.\n");
 714                 exit(1);
 715         }
 716
 717         /* Enable some SMBus stuff. */
 718         tmp = pci_read_byte(smbusdev, 0x79);
 719         tmp |= 0x01;
 720         pci_write_byte(smbusdev, 0x79, tmp);
 721
 722         /* Change southbridge. */
 723         tmp = pci_read_byte(dev, 0x48);
 724         tmp |= 0x21;
 725         pci_write_byte(dev, 0x48, tmp);
 726
 727         /* Now become a bit silly. */
 728         tmp = INB(0xc6f);
 729         OUTB(tmp, 0xeb);
 730         OUTB(tmp, 0xeb);
 731         tmp |= 0x40;
 732         OUTB(tmp, 0xc6f);
 733         OUTB(tmp, 0xeb);
 734         OUTB(tmp, 0xeb);
 735
 736         return 0;
 737 }
 738
 739 static int enable_flash_mcp55(struct pci_dev *dev, const char *name)
 740 {
 741         uint8_t old, new, byte;
 742         uint16_t word;
 743
 744         /* Set the 0-16 MB enable bits. */
 745         byte = pci_read_byte(dev, 0x88);
 746         byte |= 0xff;           /* 256K */
 747         pci_write_byte(dev, 0x88, byte);
 748         byte = pci_read_byte(dev, 0x8c);
 749         byte |= 0xff;           /* 1M */
 750         pci_write_byte(dev, 0x8c, byte);
 751         word = pci_read_word(dev, 0x90);
 752         word |= 0x7fff;         /* 16M */
 753         pci_write_word(dev, 0x90, word);
 754
 755         old = pci_read_byte(dev, 0x6d);
 756         new = old | 0x01;
 757         if (new == old)
 758                 return 0;
 759         pci_write_byte(dev, 0x6d, new);
 760
 761         if (pci_read_byte(dev, 0x6d) != new) {
 762                 printf("tried to set 0x%x to 0x%x on %s failed (WARNING ONLY)\n", 0x6d, new, name);
 763                 return -1;
 764         }
 765
 766         return 0;
 767 }
 768
 769 static int enable_flash_ht1000(struct pci_dev *dev, const char *name)
 770 {
 771         uint8_t byte;
 772
 773         /* Set the 4MB enable bit. */
 774         byte = pci_read_byte(dev, 0x41);
 775         byte |= 0x0e;
 776         pci_write_byte(dev, 0x41, byte);
 777
 778         byte = pci_read_byte(dev, 0x43);
 779         byte |= (1 << 4);
 780         pci_write_byte(dev, 0x43, byte);
 781
 782         return 0;
 783 }
 784
 785 typedef struct penable {
 786         uint16_t vendor, device;
 787         const char *name;
 788         int (*doit) (struct pci_dev *dev, const char *name);
 789 } FLASH_ENABLE;
 790
 791 static const FLASH_ENABLE enables[] = {
 792         {0x1039, 0x0630, "SiS630",              enable_flash_sis630},
 793         {0x8086, 0x122e, "Intel PIIX",          enable_flash_piix4},
 794         {0x8086, 0x1234, "Intel MPIIX",         enable_flash_piix4},
 795         {0x8086, 0x7000, "Intel PIIX3",         enable_flash_piix4},
 796         {0x8086, 0x7110, "Intel PIIX4/4E/4M",   enable_flash_piix4},
 797         {0x8086, 0x7198, "Intel 440MX",         enable_flash_piix4},
 798         {0x8086, 0x2410, "Intel ICH",           enable_flash_ich_4e},
 799         {0x8086, 0x2420, "Intel ICH0",          enable_flash_ich_4e},
 800         {0x8086, 0x2440, "Intel ICH2",          enable_flash_ich_4e},
 801         {0x8086, 0x244c, "Intel ICH2-M",        enable_flash_ich_4e},
 802         {0x8086, 0x2480, "Intel ICH3-S",        enable_flash_ich_4e},
 803         {0x8086, 0x248c, "Intel ICH3-M",        enable_flash_ich_4e},
 804         {0x8086, 0x24c0, "Intel ICH4/ICH4-L",   enable_flash_ich_4e},
 805         {0x8086, 0x24cc, "Intel ICH4-M",        enable_flash_ich_4e},
 806         {0x8086, 0x24d0, "Intel ICH5/ICH5R",    enable_flash_ich_4e},
 807         {0x8086, 0x25a1, "Intel 6300ESB",       enable_flash_ich_4e},
 808         {0x8086, 0x2640, "Intel ICH6/ICH6R",    enable_flash_ich_dc},
 809         {0x8086, 0x2641, "Intel ICH6-M",        enable_flash_ich_dc},
 810         {0x8086, 0x5031, "Intel EP80579",       enable_flash_ich7},
 811         {0x8086, 0x27b0, "Intel ICH7DH",        enable_flash_ich7},
 812         {0x8086, 0x27b8, "Intel ICH7/ICH7R",    enable_flash_ich7},
 813         {0x8086, 0x27b9, "Intel ICH7M",         enable_flash_ich7},
 814         {0x8086, 0x27bd, "Intel ICH7MDH",       enable_flash_ich7},
 815         {0x8086, 0x2810, "Intel ICH8/ICH8R",    enable_flash_ich8},
 816         {0x8086, 0x2811, "Intel ICH8M-E",       enable_flash_ich8},
 817         {0x8086, 0x2812, "Intel ICH8DH",        enable_flash_ich8},
 818         {0x8086, 0x2814, "Intel ICH8DO",        enable_flash_ich8},
 819         {0x8086, 0x2815, "Intel ICH8M",         enable_flash_ich8},
 820         {0x8086, 0x2912, "Intel ICH9DH",        enable_flash_ich9},
 821         {0x8086, 0x2914, "Intel ICH9DO",        enable_flash_ich9},
 822         {0x8086, 0x2916, "Intel ICH9R",         enable_flash_ich9},
 823         {0x8086, 0x2917, "Intel ICH9M-E",       enable_flash_ich9},
 824         {0x8086, 0x2918, "Intel ICH9",          enable_flash_ich9},
 825         {0x8086, 0x2919, "Intel ICH9M",         enable_flash_ich9},
 826         {0x8086, 0x3a14, "Intel ICH10DO",       enable_flash_ich10},
 827         {0x8086, 0x3a16, "Intel ICH10R",        enable_flash_ich10},
 828         {0x8086, 0x3a18, "Intel ICH10",         enable_flash_ich10},
 829         {0x8086, 0x3a1a, "Intel ICH10D",        enable_flash_ich10},
 830         {0x1106, 0x8231, "VIA VT8231",          enable_flash_vt823x},
 831         {0x1106, 0x3177, "VIA VT8235",          enable_flash_vt823x},
 832         {0x1106, 0x3227, "VIA VT8237",          enable_flash_vt823x},
 833         {0x1106, 0x3372, "VIA VT8237S",         enable_flash_vt8237s_spi},
 834         {0x1106, 0x8324, "VIA CX700",           enable_flash_vt823x},
 835         {0x1106, 0x0586, "VIA VT82C586A/B",     enable_flash_amd8111},
 836         {0x1106, 0x0686, "VIA VT82C686A/B",     enable_flash_amd8111},
 837         {0x1078, 0x0100, "AMD CS5530(A)",       enable_flash_cs5530},
 838         {0x100b, 0x0510, "AMD SC1100",          enable_flash_sc1100},
 839         {0x1039, 0x0008, "SiS5595",             enable_flash_sis5595},
 840         {0x1022, 0x2080, "AMD CS5536",          enable_flash_cs5536},
 841         {0x1022, 0x7468, "AMD8111",             enable_flash_amd8111},
 842         {0x1002, 0x438D, "ATI(AMD) SB600",      enable_flash_sb600},
 843         {0x10B9, 0x1533, "ALi M1533",           enable_flash_ali_m1533},
 844         {0x10de, 0x0050, "NVIDIA CK804",        enable_flash_ck804}, /* LPC */
 845         {0x10de, 0x0051, "NVIDIA CK804",        enable_flash_ck804}, /* Pro */
 846         /* Slave, should not be here, to fix known bug for A01. */
 847         {0x10de, 0x00d3, "NVIDIA CK804",        enable_flash_ck804},
 848         {0x10de, 0x0260, "NVIDIA MCP51",        enable_flash_ck804},
 849         {0x10de, 0x0261, "NVIDIA MCP51",        enable_flash_ck804},
 850         {0x10de, 0x0262, "NVIDIA MCP51",        enable_flash_ck804},
 851         {0x10de, 0x0263, "NVIDIA MCP51",        enable_flash_ck804},
 852         {0x10de, 0x0360, "NVIDIA MCP55",        enable_flash_mcp55}, /* M57SLI*/
 853         {0x10de, 0x0361, "NVIDIA MCP55",        enable_flash_mcp55}, /* LPC */
 854         {0x10de, 0x0362, "NVIDIA MCP55",        enable_flash_mcp55}, /* LPC */
 855         {0x10de, 0x0363, "NVIDIA MCP55",        enable_flash_mcp55}, /* LPC */
 856         {0x10de, 0x0364, "NVIDIA MCP55",        enable_flash_mcp55}, /* LPC */
 857         {0x10de, 0x0365, "NVIDIA MCP55",        enable_flash_mcp55}, /* LPC */
 858         {0x10de, 0x0366, "NVIDIA MCP55",        enable_flash_mcp55}, /* LPC */
 859         {0x10de, 0x0367, "NVIDIA MCP55",        enable_flash_mcp55}, /* Pro */
 860         {0x10de, 0x0548, "NVIDIA MCP67",        enable_flash_mcp55},
 861         {0x1002, 0x4377, "ATI SB400",           enable_flash_sb400},
 862         {0x1166, 0x0205, "Broadcom HT-1000",    enable_flash_ht1000},
 863 };
 864
 865 void print_supported_chipsets(void)
 866 {
 867         int i;
 868
 869         printf("\nSupported chipsets:\n\n");
 870
 871         for (i = 0; i < ARRAY_SIZE(enables); i++)
 872                 printf("%s (%04x:%04x)\n", enables[i].name,
 873                        enables[i].vendor, enables[i].device);
 874 }
 875
 876 int chipset_flash_enable(void)
 877 {
 878         struct pci_dev *dev = 0;
 879         int ret = -2;           /* Nothing! */
 880         int i;
 881
 882         /* Now let's try to find the chipset we have... */
 883         for (i = 0; i < ARRAY_SIZE(enables); i++) {
 884                 dev = pci_dev_find(enables[i].vendor, enables[i].device);
 885                 if (dev)
 886                         break;
 887         }
 888
 889         if (dev) {
 890                 printf("Found chipset \"%s\", enabling flash write... ",
 891                        enables[i].name);
 892
 893                 ret = enables[i].doit(dev, enables[i].name);
 894                 if (ret)
 895                         printf("FAILED!\n");
 896                 else
 897                         printf("OK.\n");
 898         }
 899
 900         return ret;
 901 }