qemu/hw/block/pflash_cfi01.c

   1 /*
   2  *  CFI parallel flash with Intel command set emulation
   3  *
   4  *  Copyright (c) 2006 Thorsten Zitterell
   5  *  Copyright (c) 2005 Jocelyn Mayer
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library 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 GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 /*
  22  * For now, this code can emulate flashes of 1, 2 or 4 bytes width.
  23  * Supported commands/modes are:
  24  * - flash read
  25  * - flash write
  26  * - flash ID read
  27  * - sector erase
  28  * - CFI queries
  29  *
  30  * It does not support timings
  31  * It does not support flash interleaving
  32  * It does not implement software data protection as found in many real chips
  33  * It does not implement erase suspend/resume commands
  34  * It does not implement multiple sectors erase
  35  *
  36  * It does not implement much more ...
  37  */
  38
  39 #include "qemu/osdep.h"
  40 #include "hw/hw.h"
  41 #include "hw/block/flash.h"
  42 #include "sysemu/block-backend.h"
  43 #include "qapi/error.h"
  44 #include "qemu/timer.h"
  45 #include "qemu/bitops.h"
  46 #include "exec/address-spaces.h"
  47 #include "qemu/host-utils.h"
  48 #include "hw/sysbus.h"
  49 #include "sysemu/sysemu.h"
  50
  51 #define PFLASH_BUG(fmt, ...) \
  52 do { \
  53     fprintf(stderr, "PFLASH: Possible BUG - " fmt, ## __VA_ARGS__); \
  54     exit(1); \
  55 } while(0)
  56
  57 /* #define PFLASH_DEBUG */
  58 #ifdef PFLASH_DEBUG
  59 #define DPRINTF(fmt, ...)                                   \
  60 do {                                                        \
  61     fprintf(stderr, "PFLASH: " fmt , ## __VA_ARGS__);       \
  62 } while (0)
  63 #else
  64 #define DPRINTF(fmt, ...) do { } while (0)
  65 #endif
  66
  67 #define TYPE_CFI_PFLASH01 "cfi.pflash01"
  68 #define CFI_PFLASH01(obj) OBJECT_CHECK(pflash_t, (obj), TYPE_CFI_PFLASH01)
  69
  70 #define PFLASH_BE          0
  71 #define PFLASH_SECURE      1
  72
  73 struct pflash_t {
  74     /*< private >*/
  75     SysBusDevice parent_obj;
  76     /*< public >*/
  77
  78     BlockBackend *blk;
  79     uint32_t nb_blocs;
  80     uint64_t sector_len;
  81     uint8_t bank_width;
  82     uint8_t device_width; /* If 0, device width not specified. */
  83     uint8_t max_device_width;  /* max device width in bytes */
  84     uint32_t features;
  85     uint8_t wcycle; /* if 0, the flash is read normally */
  86     int ro;
  87     uint8_t cmd;
  88     uint8_t status;
  89     uint16_t ident0;
  90     uint16_t ident1;
  91     uint16_t ident2;
  92     uint16_t ident3;
  93     uint8_t cfi_len;
  94     uint8_t cfi_table[0x52];
  95     uint64_t counter;
  96     unsigned int writeblock_size;
  97     QEMUTimer *timer;
  98     MemoryRegion mem;
  99     char *name;
 100     void *storage;
 101     VMChangeStateEntry *vmstate;
 102 };
 103
 104 static int pflash_post_load(void *opaque, int version_id);
 105
 106 static const VMStateDescription vmstate_pflash = {
 107     .name = "pflash_cfi01",
 108     .version_id = 1,
 109     .minimum_version_id = 1,
 110     .post_load = pflash_post_load,
 111     .fields = (VMStateField[]) {
 112         VMSTATE_UINT8(wcycle, pflash_t),
 113         VMSTATE_UINT8(cmd, pflash_t),
 114         VMSTATE_UINT8(status, pflash_t),
 115         VMSTATE_UINT64(counter, pflash_t),
 116         VMSTATE_END_OF_LIST()
 117     }
 118 };
 119
 120 static void pflash_timer (void *opaque)
 121 {
 122     pflash_t *pfl = opaque;
 123
 124     DPRINTF("%s: command %02x done\n", __func__, pfl->cmd);
 125     /* Reset flash */
 126     pfl->status ^= 0x80;
 127     memory_region_rom_device_set_romd(&pfl->mem, true);
 128     pfl->wcycle = 0;
 129     pfl->cmd = 0;
 130 }
 131
 132 /* Perform a CFI query based on the bank width of the flash.
 133  * If this code is called we know we have a device_width set for
 134  * this flash.
 135  */
 136 static uint32_t pflash_cfi_query(pflash_t *pfl, hwaddr offset)
 137 {
 138     int i;
 139     uint32_t resp = 0;
 140     hwaddr boff;
 141
 142     /* Adjust incoming offset to match expected device-width
 143      * addressing. CFI query addresses are always specified in terms of
 144      * the maximum supported width of the device.  This means that x8
 145      * devices and x8/x16 devices in x8 mode behave differently.  For
 146      * devices that are not used at their max width, we will be
 147      * provided with addresses that use higher address bits than
 148      * expected (based on the max width), so we will shift them lower
 149      * so that they will match the addresses used when
 150      * device_width==max_device_width.
 151      */
 152     boff = offset >> (ctz32(pfl->bank_width) +
 153                       ctz32(pfl->max_device_width) - ctz32(pfl->device_width));
 154
 155     if (boff > pfl->cfi_len) {
 156         return 0;
 157     }
 158     /* Now we will construct the CFI response generated by a single
 159      * device, then replicate that for all devices that make up the
 160      * bus.  For wide parts used in x8 mode, CFI query responses
 161      * are different than native byte-wide parts.
 162      */
 163     resp = pfl->cfi_table[boff];
 164     if (pfl->device_width != pfl->max_device_width) {
 165         /* The only case currently supported is x8 mode for a
 166          * wider part.
 167          */
 168         if (pfl->device_width != 1 || pfl->bank_width > 4) {
 169             DPRINTF("%s: Unsupported device configuration: "
 170                     "device_width=%d, max_device_width=%d\n",
 171                     __func__, pfl->device_width,
 172                     pfl->max_device_width);
 173             return 0;
 174         }
 175         /* CFI query data is repeated, rather than zero padded for
 176          * wide devices used in x8 mode.
 177          */
 178         for (i = 1; i < pfl->max_device_width; i++) {
 179             resp = deposit32(resp, 8 * i, 8, pfl->cfi_table[boff]);
 180         }
 181     }
 182     /* Replicate responses for each device in bank. */
 183     if (pfl->device_width < pfl->bank_width) {
 184         for (i = pfl->device_width;
 185              i < pfl->bank_width; i += pfl->device_width) {
 186             resp = deposit32(resp, 8 * i, 8 * pfl->device_width, resp);
 187         }
 188     }
 189
 190     return resp;
 191 }
 192
 193
 194
 195 /* Perform a device id query based on the bank width of the flash. */
 196 static uint32_t pflash_devid_query(pflash_t *pfl, hwaddr offset)
 197 {
 198     int i;
 199     uint32_t resp;
 200     hwaddr boff;
 201
 202     /* Adjust incoming offset to match expected device-width
 203      * addressing. Device ID read addresses are always specified in
 204      * terms of the maximum supported width of the device.  This means
 205      * that x8 devices and x8/x16 devices in x8 mode behave
 206      * differently. For devices that are not used at their max width,
 207      * we will be provided with addresses that use higher address bits
 208      * than expected (based on the max width), so we will shift them
 209      * lower so that they will match the addresses used when
 210      * device_width==max_device_width.
 211      */
 212     boff = offset >> (ctz32(pfl->bank_width) +
 213                       ctz32(pfl->max_device_width) - ctz32(pfl->device_width));
 214
 215     /* Mask off upper bits which may be used in to query block
 216      * or sector lock status at other addresses.
 217      * Offsets 2/3 are block lock status, is not emulated.
 218      */
 219     switch (boff & 0xFF) {
 220     case 0:
 221         resp = pfl->ident0;
 222         DPRINTF("%s: Manufacturer Code %04x\n", __func__, resp);
 223         break;
 224     case 1:
 225         resp = pfl->ident1;
 226         DPRINTF("%s: Device ID Code %04x\n", __func__, resp);
 227         break;
 228     default:
 229         DPRINTF("%s: Read Device Information offset=%x\n", __func__,
 230                 (unsigned)offset);
 231         return 0;
 232         break;
 233     }
 234     /* Replicate responses for each device in bank. */
 235     if (pfl->device_width < pfl->bank_width) {
 236         for (i = pfl->device_width;
 237               i < pfl->bank_width; i += pfl->device_width) {
 238             resp = deposit32(resp, 8 * i, 8 * pfl->device_width, resp);
 239         }
 240     }
 241
 242     return resp;
 243 }
 244
 245 static uint32_t pflash_data_read(pflash_t *pfl, hwaddr offset,
 246                                  int width, int be)
 247 {
 248     uint8_t *p;
 249     uint32_t ret;
 250
 251     p = pfl->storage;
 252     switch (width) {
 253     case 1:
 254         ret = p[offset];
 255         DPRINTF("%s: data offset " TARGET_FMT_plx " %02x\n",
 256                 __func__, offset, ret);
 257         break;
 258     case 2:
 259         if (be) {
 260             ret = p[offset] << 8;
 261             ret |= p[offset + 1];
 262         } else {
 263             ret = p[offset];
 264             ret |= p[offset + 1] << 8;
 265         }
 266         DPRINTF("%s: data offset " TARGET_FMT_plx " %04x\n",
 267                 __func__, offset, ret);
 268         break;
 269     case 4:
 270         if (be) {
 271             ret = p[offset] << 24;
 272             ret |= p[offset + 1] << 16;
 273             ret |= p[offset + 2] << 8;
 274             ret |= p[offset + 3];
 275         } else {
 276             ret = p[offset];
 277             ret |= p[offset + 1] << 8;
 278             ret |= p[offset + 2] << 16;
 279             ret |= p[offset + 3] << 24;
 280         }
 281         DPRINTF("%s: data offset " TARGET_FMT_plx " %08x\n",
 282                 __func__, offset, ret);
 283         break;
 284     default:
 285         DPRINTF("BUG in %s\n", __func__);
 286         abort();
 287     }
 288     return ret;
 289 }
 290
 291 static uint32_t pflash_read (pflash_t *pfl, hwaddr offset,
 292                              int width, int be)
 293 {
 294     hwaddr boff;
 295     uint32_t ret;
 296
 297     ret = -1;
 298
 299 #if 0
 300     DPRINTF("%s: reading offset " TARGET_FMT_plx " under cmd %02x width %d\n",
 301             __func__, offset, pfl->cmd, width);
 302 #endif
 303     switch (pfl->cmd) {
 304     default:
 305         /* This should never happen : reset state & treat it as a read */
 306         DPRINTF("%s: unknown command state: %x\n", __func__, pfl->cmd);
 307         pfl->wcycle = 0;
 308         pfl->cmd = 0;
 309         /* fall through to read code */
 310     case 0x00:
 311         /* Flash area read */
 312         ret = pflash_data_read(pfl, offset, width, be);
 313         break;
 314     case 0x10: /* Single byte program */
 315     case 0x20: /* Block erase */
 316     case 0x28: /* Block erase */
 317     case 0x40: /* single byte program */
 318     case 0x50: /* Clear status register */
 319     case 0x60: /* Block /un)lock */
 320     case 0x70: /* Status Register */
 321     case 0xe8: /* Write block */
 322         /* Status register read.  Return status from each device in
 323          * bank.
 324          */
 325         ret = pfl->status;
 326         if (pfl->device_width && width > pfl->device_width) {
 327             int shift = pfl->device_width * 8;
 328             while (shift + pfl->device_width * 8 <= width * 8) {
 329                 ret |= pfl->status << shift;
 330                 shift += pfl->device_width * 8;
 331             }
 332         } else if (!pfl->device_width && width > 2) {
 333             /* Handle 32 bit flash cases where device width is not
 334              * set. (Existing behavior before device width added.)
 335              */
 336             ret |= pfl->status << 16;
 337         }
 338         DPRINTF("%s: status %x\n", __func__, ret);
 339         break;
 340     case 0x90:
 341         if (!pfl->device_width) {
 342             /* Preserve old behavior if device width not specified */
 343             boff = offset & 0xFF;
 344             if (pfl->bank_width == 2) {
 345                 boff = boff >> 1;
 346             } else if (pfl->bank_width == 4) {
 347                 boff = boff >> 2;
 348             }
 349
 350             switch (boff) {
 351             case 0:
 352                 ret = pfl->ident0 << 8 | pfl->ident1;
 353                 DPRINTF("%s: Manufacturer Code %04x\n", __func__, ret);
 354                 break;
 355             case 1:
 356                 ret = pfl->ident2 << 8 | pfl->ident3;
 357                 DPRINTF("%s: Device ID Code %04x\n", __func__, ret);
 358                 break;
 359             default:
 360                 DPRINTF("%s: Read Device Information boff=%x\n", __func__,
 361                         (unsigned)boff);
 362                 ret = 0;
 363                 break;
 364             }
 365         } else {
 366             /* If we have a read larger than the bank_width, combine multiple
 367              * manufacturer/device ID queries into a single response.
 368              */
 369             int i;
 370             for (i = 0; i < width; i += pfl->bank_width) {
 371                 ret = deposit32(ret, i * 8, pfl->bank_width * 8,
 372                                 pflash_devid_query(pfl,
 373                                                  offset + i * pfl->bank_width));
 374             }
 375         }
 376         break;
 377     case 0x98: /* Query mode */
 378         if (!pfl->device_width) {
 379             /* Preserve old behavior if device width not specified */
 380             boff = offset & 0xFF;
 381             if (pfl->bank_width == 2) {
 382                 boff = boff >> 1;
 383             } else if (pfl->bank_width == 4) {
 384                 boff = boff >> 2;
 385             }
 386
 387             if (boff > pfl->cfi_len) {
 388                 ret = 0;
 389             } else {
 390                 ret = pfl->cfi_table[boff];
 391             }
 392         } else {
 393             /* If we have a read larger than the bank_width, combine multiple
 394              * CFI queries into a single response.
 395              */
 396             int i;
 397             for (i = 0; i < width; i += pfl->bank_width) {
 398                 ret = deposit32(ret, i * 8, pfl->bank_width * 8,
 399                                 pflash_cfi_query(pfl,
 400                                                  offset + i * pfl->bank_width));
 401             }
 402         }
 403
 404         break;
 405     }
 406     return ret;
 407 }
 408
 409 /* update flash content on disk */
 410 static void pflash_update(pflash_t *pfl, int offset,
 411                           int size)
 412 {
 413     int offset_end;
 414     if (pfl->blk) {
 415         offset_end = offset + size;
 416         /* round to sectors */
 417         offset = offset >> 9;
 418         offset_end = (offset_end + 511) >> 9;
 419         blk_write(pfl->blk, offset, pfl->storage + (offset << 9),
 420                   offset_end - offset);
 421     }
 422 }
 423
 424 static inline void pflash_data_write(pflash_t *pfl, hwaddr offset,
 425                                      uint32_t value, int width, int be)
 426 {
 427     uint8_t *p = pfl->storage;
 428
 429     DPRINTF("%s: block write offset " TARGET_FMT_plx
 430             " value %x counter %016" PRIx64 "\n",
 431             __func__, offset, value, pfl->counter);
 432     switch (width) {
 433     case 1:
 434         p[offset] = value;
 435         break;
 436     case 2:
 437         if (be) {
 438             p[offset] = value >> 8;
 439             p[offset + 1] = value;
 440         } else {
 441             p[offset] = value;
 442             p[offset + 1] = value >> 8;
 443         }
 444         break;
 445     case 4:
 446         if (be) {
 447             p[offset] = value >> 24;
 448             p[offset + 1] = value >> 16;
 449             p[offset + 2] = value >> 8;
 450             p[offset + 3] = value;
 451         } else {
 452             p[offset] = value;
 453             p[offset + 1] = value >> 8;
 454             p[offset + 2] = value >> 16;
 455             p[offset + 3] = value >> 24;
 456         }
 457         break;
 458     }
 459
 460 }
 461
 462 static void pflash_write(pflash_t *pfl, hwaddr offset,
 463                          uint32_t value, int width, int be)
 464 {
 465     uint8_t *p;
 466     uint8_t cmd;
 467
 468     cmd = value;
 469
 470     DPRINTF("%s: writing offset " TARGET_FMT_plx " value %08x width %d wcycle 0x%x\n",
 471             __func__, offset, value, width, pfl->wcycle);
 472
 473     if (!pfl->wcycle) {
 474         /* Set the device in I/O access mode */
 475         memory_region_rom_device_set_romd(&pfl->mem, false);
 476     }
 477
 478     switch (pfl->wcycle) {
 479     case 0:
 480         /* read mode */
 481         switch (cmd) {
 482         case 0x00: /* ??? */
 483             goto reset_flash;
 484         case 0x10: /* Single Byte Program */
 485         case 0x40: /* Single Byte Program */
 486             DPRINTF("%s: Single Byte Program\n", __func__);
 487             break;
 488         case 0x20: /* Block erase */
 489             p = pfl->storage;
 490             offset &= ~(pfl->sector_len - 1);
 491
 492             DPRINTF("%s: block erase at " TARGET_FMT_plx " bytes %x\n",
 493                     __func__, offset, (unsigned)pfl->sector_len);
 494
 495             if (!pfl->ro) {
 496                 memset(p + offset, 0xff, pfl->sector_len);
 497                 pflash_update(pfl, offset, pfl->sector_len);
 498             } else {
 499                 pfl->status |= 0x20; /* Block erase error */
 500             }
 501             pfl->status |= 0x80; /* Ready! */
 502             break;
 503         case 0x50: /* Clear status bits */
 504             DPRINTF("%s: Clear status bits\n", __func__);
 505             pfl->status = 0x0;
 506             goto reset_flash;
 507         case 0x60: /* Block (un)lock */
 508             DPRINTF("%s: Block unlock\n", __func__);
 509             break;
 510         case 0x70: /* Status Register */
 511             DPRINTF("%s: Read status register\n", __func__);
 512             pfl->cmd = cmd;
 513             return;
 514         case 0x90: /* Read Device ID */
 515             DPRINTF("%s: Read Device information\n", __func__);
 516             pfl->cmd = cmd;
 517             return;
 518         case 0x98: /* CFI query */
 519             DPRINTF("%s: CFI query\n", __func__);
 520             break;
 521         case 0xe8: /* Write to buffer */
 522             DPRINTF("%s: Write to buffer\n", __func__);
 523             pfl->status |= 0x80; /* Ready! */
 524             break;
 525         case 0xf0: /* Probe for AMD flash */
 526             DPRINTF("%s: Probe for AMD flash\n", __func__);
 527             goto reset_flash;
 528         case 0xff: /* Read array mode */
 529             DPRINTF("%s: Read array mode\n", __func__);
 530             goto reset_flash;
 531         default:
 532             goto error_flash;
 533         }
 534         pfl->wcycle++;
 535         pfl->cmd = cmd;
 536         break;
 537     case 1:
 538         switch (pfl->cmd) {
 539         case 0x10: /* Single Byte Program */
 540         case 0x40: /* Single Byte Program */
 541             DPRINTF("%s: Single Byte Program\n", __func__);
 542             if (!pfl->ro) {
 543                 pflash_data_write(pfl, offset, value, width, be);
 544                 pflash_update(pfl, offset, width);
 545             } else {
 546                 pfl->status |= 0x10; /* Programming error */
 547             }
 548             pfl->status |= 0x80; /* Ready! */
 549             pfl->wcycle = 0;
 550         break;
 551         case 0x20: /* Block erase */
 552         case 0x28:
 553             if (cmd == 0xd0) { /* confirm */
 554                 pfl->wcycle = 0;
 555                 pfl->status |= 0x80;
 556             } else if (cmd == 0xff) { /* read array mode */
 557                 goto reset_flash;
 558             } else
 559                 goto error_flash;
 560
 561             break;
 562         case 0xe8:
 563             /* Mask writeblock size based on device width, or bank width if
 564              * device width not specified.
 565              */
 566             if (pfl->device_width) {
 567                 value = extract32(value, 0, pfl->device_width * 8);
 568             } else {
 569                 value = extract32(value, 0, pfl->bank_width * 8);
 570             }
 571             DPRINTF("%s: block write of %x bytes\n", __func__, value);
 572             pfl->counter = value;
 573             pfl->wcycle++;
 574             break;
 575         case 0x60:
 576             if (cmd == 0xd0) {
 577                 pfl->wcycle = 0;
 578                 pfl->status |= 0x80;
 579             } else if (cmd == 0x01) {
 580                 pfl->wcycle = 0;
 581                 pfl->status |= 0x80;
 582             } else if (cmd == 0xff) {
 583                 goto reset_flash;
 584             } else {
 585                 DPRINTF("%s: Unknown (un)locking command\n", __func__);
 586                 goto reset_flash;
 587             }
 588             break;
 589         case 0x98:
 590             if (cmd == 0xff) {
 591                 goto reset_flash;
 592             } else {
 593                 DPRINTF("%s: leaving query mode\n", __func__);
 594             }
 595             break;
 596         default:
 597             goto error_flash;
 598         }
 599         break;
 600     case 2:
 601         switch (pfl->cmd) {
 602         case 0xe8: /* Block write */
 603             if (!pfl->ro) {
 604                 pflash_data_write(pfl, offset, value, width, be);
 605             } else {
 606                 pfl->status |= 0x10; /* Programming error */
 607             }
 608
 609             pfl->status |= 0x80;
 610
 611             if (!pfl->counter) {
 612                 hwaddr mask = pfl->writeblock_size - 1;
 613                 mask = ~mask;
 614
 615                 DPRINTF("%s: block write finished\n", __func__);
 616                 pfl->wcycle++;
 617                 if (!pfl->ro) {
 618                     /* Flush the entire write buffer onto backing storage.  */
 619                     pflash_update(pfl, offset & mask, pfl->writeblock_size);
 620                 } else {
 621                     pfl->status |= 0x10; /* Programming error */
 622                 }
 623             }
 624
 625             pfl->counter--;
 626             break;
 627         default:
 628             goto error_flash;
 629         }
 630         break;
 631     case 3: /* Confirm mode */
 632         switch (pfl->cmd) {
 633         case 0xe8: /* Block write */
 634             if (cmd == 0xd0) {
 635                 pfl->wcycle = 0;
 636                 pfl->status |= 0x80;
 637             } else {
 638                 DPRINTF("%s: unknown command for \"write block\"\n", __func__);
 639                 PFLASH_BUG("Write block confirm");
 640                 goto reset_flash;
 641             }
 642             break;
 643         default:
 644             goto error_flash;
 645         }
 646         break;
 647     default:
 648         /* Should never happen */
 649         DPRINTF("%s: invalid write state\n",  __func__);
 650         goto reset_flash;
 651     }
 652     return;
 653
 654  error_flash:
 655     qemu_log_mask(LOG_UNIMP, "%s: Unimplemented flash cmd sequence "
 656                   "(offset " TARGET_FMT_plx ", wcycle 0x%x cmd 0x%x value 0x%x)"
 657                   "\n", __func__, offset, pfl->wcycle, pfl->cmd, value);
 658
 659  reset_flash:
 660     memory_region_rom_device_set_romd(&pfl->mem, true);
 661
 662     pfl->wcycle = 0;
 663     pfl->cmd = 0;
 664 }
 665
 666
 667 static MemTxResult pflash_mem_read_with_attrs(void *opaque, hwaddr addr, uint64_t *value,
 668                                               unsigned len, MemTxAttrs attrs)
 669 {
 670     pflash_t *pfl = opaque;
 671     bool be = !!(pfl->features & (1 << PFLASH_BE));
 672
 673     if ((pfl->features & (1 << PFLASH_SECURE)) && !attrs.secure) {
 674         *value = pflash_data_read(opaque, addr, len, be);
 675     } else {
 676         *value = pflash_read(opaque, addr, len, be);
 677     }
 678     return MEMTX_OK;
 679 }
 680
 681 static MemTxResult pflash_mem_write_with_attrs(void *opaque, hwaddr addr, uint64_t value,
 682                                                unsigned len, MemTxAttrs attrs)
 683 {
 684     pflash_t *pfl = opaque;
 685     bool be = !!(pfl->features & (1 << PFLASH_BE));
 686
 687     if ((pfl->features & (1 << PFLASH_SECURE)) && !attrs.secure) {
 688         return MEMTX_ERROR;
 689     } else {
 690         pflash_write(opaque, addr, value, len, be);
 691         return MEMTX_OK;
 692     }
 693 }
 694
 695 static const MemoryRegionOps pflash_cfi01_ops = {
 696     .read_with_attrs = pflash_mem_read_with_attrs,
 697     .write_with_attrs = pflash_mem_write_with_attrs,
 698     .endianness = DEVICE_NATIVE_ENDIAN,
 699 };
 700
 701 static void pflash_cfi01_realize(DeviceState *dev, Error **errp)
 702 {
 703     pflash_t *pfl = CFI_PFLASH01(dev);
 704     uint64_t total_len;
 705     int ret;
 706     uint64_t blocks_per_device, device_len;
 707     int num_devices;
 708     Error *local_err = NULL;
 709
 710     total_len = pfl->sector_len * pfl->nb_blocs;
 711
 712     /* These are only used to expose the parameters of each device
 713      * in the cfi_table[].
 714      */
 715     num_devices = pfl->device_width ? (pfl->bank_width / pfl->device_width) : 1;
 716     blocks_per_device = pfl->nb_blocs / num_devices;
 717     device_len = pfl->sector_len * blocks_per_device;
 718
 719     /* XXX: to be fixed */
 720 #if 0
 721     if (total_len != (8 * 1024 * 1024) && total_len != (16 * 1024 * 1024) &&
 722         total_len != (32 * 1024 * 1024) && total_len != (64 * 1024 * 1024))
 723         return NULL;
 724 #endif
 725
 726     memory_region_init_rom_device(
 727         &pfl->mem, OBJECT(dev),
 728         &pflash_cfi01_ops,
 729         pfl,
 730         pfl->name, total_len, &local_err);
 731     if (local_err) {
 732         error_propagate(errp, local_err);
 733         return;
 734     }
 735
 736     vmstate_register_ram(&pfl->mem, DEVICE(pfl));
 737     pfl->storage = memory_region_get_ram_ptr(&pfl->mem);
 738     sysbus_init_mmio(SYS_BUS_DEVICE(dev), &pfl->mem);
 739
 740     if (pfl->blk) {
 741         /* read the initial flash content */
 742         ret = blk_read(pfl->blk, 0, pfl->storage, total_len >> 9);
 743
 744         if (ret < 0) {
 745             vmstate_unregister_ram(&pfl->mem, DEVICE(pfl));
 746             error_setg(errp, "failed to read the initial flash content");
 747             return;
 748         }
 749     }
 750
 751     if (pfl->blk) {
 752         pfl->ro = blk_is_read_only(pfl->blk);
 753     } else {
 754         pfl->ro = 0;
 755     }
 756
 757     /* Default to devices being used at their maximum device width. This was
 758      * assumed before the device_width support was added.
 759      */
 760     if (!pfl->max_device_width) {
 761         pfl->max_device_width = pfl->device_width;
 762     }
 763
 764     pfl->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, pflash_timer, pfl);
 765     pfl->wcycle = 0;
 766     pfl->cmd = 0;
 767     pfl->status = 0;
 768     /* Hardcoded CFI table */
 769     pfl->cfi_len = 0x52;
 770     /* Standard "QRY" string */
 771     pfl->cfi_table[0x10] = 'Q';
 772     pfl->cfi_table[0x11] = 'R';
 773     pfl->cfi_table[0x12] = 'Y';
 774     /* Command set (Intel) */
 775     pfl->cfi_table[0x13] = 0x01;
 776     pfl->cfi_table[0x14] = 0x00;
 777     /* Primary extended table address (none) */
 778     pfl->cfi_table[0x15] = 0x31;
 779     pfl->cfi_table[0x16] = 0x00;
 780     /* Alternate command set (none) */
 781     pfl->cfi_table[0x17] = 0x00;
 782     pfl->cfi_table[0x18] = 0x00;
 783     /* Alternate extended table (none) */
 784     pfl->cfi_table[0x19] = 0x00;
 785     pfl->cfi_table[0x1A] = 0x00;
 786     /* Vcc min */
 787     pfl->cfi_table[0x1B] = 0x45;
 788     /* Vcc max */
 789     pfl->cfi_table[0x1C] = 0x55;
 790     /* Vpp min (no Vpp pin) */
 791     pfl->cfi_table[0x1D] = 0x00;
 792     /* Vpp max (no Vpp pin) */
 793     pfl->cfi_table[0x1E] = 0x00;
 794     /* Reserved */
 795     pfl->cfi_table[0x1F] = 0x07;
 796     /* Timeout for min size buffer write */
 797     pfl->cfi_table[0x20] = 0x07;
 798     /* Typical timeout for block erase */
 799     pfl->cfi_table[0x21] = 0x0a;
 800     /* Typical timeout for full chip erase (4096 ms) */
 801     pfl->cfi_table[0x22] = 0x00;
 802     /* Reserved */
 803     pfl->cfi_table[0x23] = 0x04;
 804     /* Max timeout for buffer write */
 805     pfl->cfi_table[0x24] = 0x04;
 806     /* Max timeout for block erase */
 807     pfl->cfi_table[0x25] = 0x04;
 808     /* Max timeout for chip erase */
 809     pfl->cfi_table[0x26] = 0x00;
 810     /* Device size */
 811     pfl->cfi_table[0x27] = ctz32(device_len); /* + 1; */
 812     /* Flash device interface (8 & 16 bits) */
 813     pfl->cfi_table[0x28] = 0x02;
 814     pfl->cfi_table[0x29] = 0x00;
 815     /* Max number of bytes in multi-bytes write */
 816     if (pfl->bank_width == 1) {
 817         pfl->cfi_table[0x2A] = 0x08;
 818     } else {
 819         pfl->cfi_table[0x2A] = 0x0B;
 820     }
 821     pfl->writeblock_size = 1 << pfl->cfi_table[0x2A];
 822
 823     pfl->cfi_table[0x2B] = 0x00;
 824     /* Number of erase block regions (uniform) */
 825     pfl->cfi_table[0x2C] = 0x01;
 826     /* Erase block region 1 */
 827     pfl->cfi_table[0x2D] = blocks_per_device - 1;
 828     pfl->cfi_table[0x2E] = (blocks_per_device - 1) >> 8;
 829     pfl->cfi_table[0x2F] = pfl->sector_len >> 8;
 830     pfl->cfi_table[0x30] = pfl->sector_len >> 16;
 831
 832     /* Extended */
 833     pfl->cfi_table[0x31] = 'P';
 834     pfl->cfi_table[0x32] = 'R';
 835     pfl->cfi_table[0x33] = 'I';
 836
 837     pfl->cfi_table[0x34] = '1';
 838     pfl->cfi_table[0x35] = '0';
 839
 840     pfl->cfi_table[0x36] = 0x00;
 841     pfl->cfi_table[0x37] = 0x00;
 842     pfl->cfi_table[0x38] = 0x00;
 843     pfl->cfi_table[0x39] = 0x00;
 844
 845     pfl->cfi_table[0x3a] = 0x00;
 846
 847     pfl->cfi_table[0x3b] = 0x00;
 848     pfl->cfi_table[0x3c] = 0x00;
 849
 850     pfl->cfi_table[0x3f] = 0x01; /* Number of protection fields */
 851 }
 852
 853 static Property pflash_cfi01_properties[] = {
 854     DEFINE_PROP_DRIVE("drive", struct pflash_t, blk),
 855     /* num-blocks is the number of blocks actually visible to the guest,
 856      * ie the total size of the device divided by the sector length.
 857      * If we're emulating flash devices wired in parallel the actual
 858      * number of blocks per indvidual device will differ.
 859      */
 860     DEFINE_PROP_UINT32("num-blocks", struct pflash_t, nb_blocs, 0),
 861     DEFINE_PROP_UINT64("sector-length", struct pflash_t, sector_len, 0),
 862     /* width here is the overall width of this QEMU device in bytes.
 863      * The QEMU device may be emulating a number of flash devices
 864      * wired up in parallel; the width of each individual flash
 865      * device should be specified via device-width. If the individual
 866      * devices have a maximum width which is greater than the width
 867      * they are being used for, this maximum width should be set via
 868      * max-device-width (which otherwise defaults to device-width).
 869      * So for instance a 32-bit wide QEMU flash device made from four
 870      * 16-bit flash devices used in 8-bit wide mode would be configured
 871      * with width = 4, device-width = 1, max-device-width = 2.
 872      *
 873      * If device-width is not specified we default to backwards
 874      * compatible behaviour which is a bad emulation of two
 875      * 16 bit devices making up a 32 bit wide QEMU device. This
 876      * is deprecated for new uses of this device.
 877      */
 878     DEFINE_PROP_UINT8("width", struct pflash_t, bank_width, 0),
 879     DEFINE_PROP_UINT8("device-width", struct pflash_t, device_width, 0),
 880     DEFINE_PROP_UINT8("max-device-width", struct pflash_t, max_device_width, 0),
 881     DEFINE_PROP_BIT("big-endian", struct pflash_t, features, PFLASH_BE, 0),
 882     DEFINE_PROP_BIT("secure", struct pflash_t, features, PFLASH_SECURE, 0),
 883     DEFINE_PROP_UINT16("id0", struct pflash_t, ident0, 0),
 884     DEFINE_PROP_UINT16("id1", struct pflash_t, ident1, 0),
 885     DEFINE_PROP_UINT16("id2", struct pflash_t, ident2, 0),
 886     DEFINE_PROP_UINT16("id3", struct pflash_t, ident3, 0),
 887     DEFINE_PROP_STRING("name", struct pflash_t, name),
 888     DEFINE_PROP_END_OF_LIST(),
 889 };
 890
 891 static void pflash_cfi01_class_init(ObjectClass *klass, void *data)
 892 {
 893     DeviceClass *dc = DEVICE_CLASS(klass);
 894
 895     dc->realize = pflash_cfi01_realize;
 896     dc->props = pflash_cfi01_properties;
 897     dc->vmsd = &vmstate_pflash;
 898     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 899 }
 900
 901
 902 static const TypeInfo pflash_cfi01_info = {
 903     .name           = TYPE_CFI_PFLASH01,
 904     .parent         = TYPE_SYS_BUS_DEVICE,
 905     .instance_size  = sizeof(struct pflash_t),
 906     .class_init     = pflash_cfi01_class_init,
 907 };
 908
 909 static void pflash_cfi01_register_types(void)
 910 {
 911     type_register_static(&pflash_cfi01_info);
 912 }
 913
 914 type_init(pflash_cfi01_register_types)
 915
 916 pflash_t *pflash_cfi01_register(hwaddr base,
 917                                 DeviceState *qdev, const char *name,
 918                                 hwaddr size,
 919                                 BlockBackend *blk,
 920                                 uint32_t sector_len, int nb_blocs,
 921                                 int bank_width, uint16_t id0, uint16_t id1,
 922                                 uint16_t id2, uint16_t id3, int be)
 923 {
 924     DeviceState *dev = qdev_create(NULL, TYPE_CFI_PFLASH01);
 925
 926     if (blk) {
 927         qdev_prop_set_drive(dev, "drive", blk, &error_abort);
 928     }
 929     qdev_prop_set_uint32(dev, "num-blocks", nb_blocs);
 930     qdev_prop_set_uint64(dev, "sector-length", sector_len);
 931     qdev_prop_set_uint8(dev, "width", bank_width);
 932     qdev_prop_set_bit(dev, "big-endian", !!be);
 933     qdev_prop_set_uint16(dev, "id0", id0);
 934     qdev_prop_set_uint16(dev, "id1", id1);
 935     qdev_prop_set_uint16(dev, "id2", id2);
 936     qdev_prop_set_uint16(dev, "id3", id3);
 937     qdev_prop_set_string(dev, "name", name);
 938     qdev_init_nofail(dev);
 939
 940     sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
 941     return CFI_PFLASH01(dev);
 942 }
 943
 944 MemoryRegion *pflash_cfi01_get_memory(pflash_t *fl)
 945 {
 946     return &fl->mem;
 947 }
 948
 949 static void postload_update_cb(void *opaque, int running, RunState state)
 950 {
 951     pflash_t *pfl = opaque;
 952
 953     /* This is called after bdrv_invalidate_cache_all.  */
 954     qemu_del_vm_change_state_handler(pfl->vmstate);
 955     pfl->vmstate = NULL;
 956
 957     DPRINTF("%s: updating bdrv for %s\n", __func__, pfl->name);
 958     pflash_update(pfl, 0, pfl->sector_len * pfl->nb_blocs);
 959 }
 960
 961 static int pflash_post_load(void *opaque, int version_id)
 962 {
 963     pflash_t *pfl = opaque;
 964
 965     if (!pfl->ro) {
 966         pfl->vmstate = qemu_add_vm_change_state_handler(postload_update_cb,
 967                                                         pfl);
 968     }
 969     return 0;
 970 }