hw/scsi/mptconfig.c

   1 /*
   2  * QEMU LSI SAS1068 Host Bus Adapter emulation - configuration pages
   3  *
   4  * Copyright (c) 2016 Red Hat, Inc.
   5  *
   6  * Author: Paolo Bonzini
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  */
  18 #include "qemu/osdep.h"
  19 #include "hw/hw.h"
  20 #include "hw/pci/pci.h"
  21 #include "hw/scsi/scsi.h"
  22
  23 #include "mptsas.h"
  24 #include "mpi.h"
  25 #include "trace.h"
  26
  27 /* Generic functions for marshaling and unmarshaling.  */
  28
  29 #define repl1(x) x
  30 #define repl2(x) x x
  31 #define repl3(x) x x x
  32 #define repl4(x) x x x x
  33 #define repl5(x) x x x x x
  34 #define repl6(x) x x x x x x
  35 #define repl7(x) x x x x x x x
  36 #define repl8(x) x x x x x x x x
  37
  38 #define repl(n, x) glue(repl, n)(x)
  39
  40 typedef union PackValue {
  41     uint64_t ll;
  42     char *str;
  43 } PackValue;
  44
  45 static size_t vfill(uint8_t *data, size_t size, const char *fmt, va_list ap)
  46 {
  47     size_t ofs;
  48     PackValue val;
  49     const char *p;
  50
  51     ofs = 0;
  52     p = fmt;
  53     while (*p) {
  54         memset(&val, 0, sizeof(val));
  55         switch (*p) {
  56         case '*':
  57             p++;
  58             break;
  59         case 'b':
  60         case 'w':
  61         case 'l':
  62             val.ll = va_arg(ap, int);
  63             break;
  64         case 'q':
  65             val.ll = va_arg(ap, int64_t);
  66             break;
  67         case 's':
  68             val.str = va_arg(ap, void *);
  69             break;
  70         }
  71         switch (*p++) {
  72         case 'b':
  73             if (data) {
  74                 stb_p(data + ofs, val.ll);
  75             }
  76             ofs++;
  77             break;
  78         case 'w':
  79             if (data) {
  80                 stw_le_p(data + ofs, val.ll);
  81             }
  82             ofs += 2;
  83             break;
  84         case 'l':
  85             if (data) {
  86                 stl_le_p(data + ofs, val.ll);
  87             }
  88             ofs += 4;
  89             break;
  90         case 'q':
  91             if (data) {
  92                 stq_le_p(data + ofs, val.ll);
  93             }
  94             ofs += 8;
  95             break;
  96         case 's':
  97             {
  98                 int cnt = atoi(p);
  99                 if (data) {
 100                     if (val.str) {
 101                         strncpy((void *)data + ofs, val.str, cnt);
 102                     } else {
 103                         memset((void *)data + ofs, 0, cnt);
 104                     }
 105                 }
 106                 ofs += cnt;
 107                 break;
 108             }
 109         }
 110     }
 111
 112     return ofs;
 113 }
 114
 115 static size_t vpack(uint8_t **p_data, const char *fmt, va_list ap1)
 116 {
 117     size_t size = 0;
 118     uint8_t *data = NULL;
 119
 120     if (p_data) {
 121         va_list ap2;
 122
 123         va_copy(ap2, ap1);
 124         size = vfill(NULL, 0, fmt, ap2);
 125         *p_data = data = g_malloc(size);
 126         va_end(ap2);
 127     }
 128     return vfill(data, size, fmt, ap1);
 129 }
 130
 131 static size_t fill(uint8_t *data, size_t size, const char *fmt, ...)
 132 {
 133     va_list ap;
 134     size_t ret;
 135
 136     va_start(ap, fmt);
 137     ret = vfill(data, size, fmt, ap);
 138     va_end(ap);
 139
 140     return ret;
 141 }
 142
 143 /* Functions to build the page header and fill in the length, always used
 144  * through the macros.
 145  */
 146
 147 #define MPTSAS_CONFIG_PACK(number, type, version, fmt, ...)                  \
 148     mptsas_config_pack(data, "b*bbb" fmt, version, number, type,             \
 149                        ## __VA_ARGS__)
 150
 151 static size_t mptsas_config_pack(uint8_t **data, const char *fmt, ...)
 152 {
 153     va_list ap;
 154     size_t ret;
 155
 156     va_start(ap, fmt);
 157     ret = vpack(data, fmt, ap);
 158     va_end(ap);
 159
 160     if (data) {
 161         assert(ret / 4 < 256 && (ret % 4) == 0);
 162         stb_p(*data + 1, ret / 4);
 163     }
 164     return ret;
 165 }
 166
 167 #define MPTSAS_CONFIG_PACK_EXT(number, type, version, fmt, ...)              \
 168     mptsas_config_pack_ext(data, "b*bbb*wb*b" fmt, version, number,          \
 169                            MPI_CONFIG_PAGETYPE_EXTENDED, type, ## __VA_ARGS__)
 170
 171 static size_t mptsas_config_pack_ext(uint8_t **data, const char *fmt, ...)
 172 {
 173     va_list ap;
 174     size_t ret;
 175
 176     va_start(ap, fmt);
 177     ret = vpack(data, fmt, ap);
 178     va_end(ap);
 179
 180     if (data) {
 181         assert(ret < 65536 && (ret % 4) == 0);
 182         stw_le_p(*data + 4, ret / 4);
 183     }
 184     return ret;
 185 }
 186
 187 /* Manufacturing pages */
 188
 189 static
 190 size_t mptsas_config_manufacturing_0(MPTSASState *s, uint8_t **data, int address)
 191 {
 192     return MPTSAS_CONFIG_PACK(0, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
 193                               "s16s8s16s16s16",
 194                               "QEMU MPT Fusion",
 195                               "2.5",
 196                               "QEMU MPT Fusion",
 197                               "QEMU",
 198                               "0000111122223333");
 199 }
 200
 201 static
 202 size_t mptsas_config_manufacturing_1(MPTSASState *s, uint8_t **data, int address)
 203 {
 204     /* VPD - all zeros */
 205     return MPTSAS_CONFIG_PACK(1, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
 206                               "*s256");
 207 }
 208
 209 static
 210 size_t mptsas_config_manufacturing_2(MPTSASState *s, uint8_t **data, int address)
 211 {
 212     PCIDeviceClass *pcic = PCI_DEVICE_GET_CLASS(s);
 213     return MPTSAS_CONFIG_PACK(2, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
 214                               "wb*b*l",
 215                               pcic->device_id, pcic->revision);
 216 }
 217
 218 static
 219 size_t mptsas_config_manufacturing_3(MPTSASState *s, uint8_t **data, int address)
 220 {
 221     PCIDeviceClass *pcic = PCI_DEVICE_GET_CLASS(s);
 222     return MPTSAS_CONFIG_PACK(3, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
 223                               "wb*b*l",
 224                               pcic->device_id, pcic->revision);
 225 }
 226
 227 static
 228 size_t mptsas_config_manufacturing_4(MPTSASState *s, uint8_t **data, int address)
 229 {
 230     /* All zeros */
 231     return MPTSAS_CONFIG_PACK(4, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x05,
 232                               "*l*b*b*b*b*b*b*w*s56*l*l*l*l*l*l"
 233                               "*b*b*w*b*b*w*l*l");
 234 }
 235
 236 static
 237 size_t mptsas_config_manufacturing_5(MPTSASState *s, uint8_t **data, int address)
 238 {
 239     return MPTSAS_CONFIG_PACK(5, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x02,
 240                               "q*b*b*w*l*l", s->sas_addr);
 241 }
 242
 243 static
 244 size_t mptsas_config_manufacturing_6(MPTSASState *s, uint8_t **data, int address)
 245 {
 246     return MPTSAS_CONFIG_PACK(6, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
 247                               "*l");
 248 }
 249
 250 static
 251 size_t mptsas_config_manufacturing_7(MPTSASState *s, uint8_t **data, int address)
 252 {
 253     return MPTSAS_CONFIG_PACK(7, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
 254                               "*l*l*l*s16*b*b*w", MPTSAS_NUM_PORTS);
 255 }
 256
 257 static
 258 size_t mptsas_config_manufacturing_8(MPTSASState *s, uint8_t **data, int address)
 259 {
 260     return MPTSAS_CONFIG_PACK(8, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
 261                               "*l");
 262 }
 263
 264 static
 265 size_t mptsas_config_manufacturing_9(MPTSASState *s, uint8_t **data, int address)
 266 {
 267     return MPTSAS_CONFIG_PACK(9, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
 268                               "*l");
 269 }
 270
 271 static
 272 size_t mptsas_config_manufacturing_10(MPTSASState *s, uint8_t **data, int address)
 273 {
 274     return MPTSAS_CONFIG_PACK(10, MPI_CONFIG_PAGETYPE_MANUFACTURING, 0x00,
 275                               "*l");
 276 }
 277
 278 /* I/O unit pages */
 279
 280 static
 281 size_t mptsas_config_io_unit_0(MPTSASState *s, uint8_t **data, int address)
 282 {
 283     PCIDevice *pci = PCI_DEVICE(s);
 284     uint64_t unique_value = 0x53504D554D4551LL;  /* "QEMUMPTx" */
 285
 286     unique_value |= (uint64_t)pci->devfn << 56;
 287     return MPTSAS_CONFIG_PACK(0, MPI_CONFIG_PAGETYPE_IO_UNIT, 0x00,
 288                               "q", unique_value);
 289 }
 290
 291 static
 292 size_t mptsas_config_io_unit_1(MPTSASState *s, uint8_t **data, int address)
 293 {
 294     return MPTSAS_CONFIG_PACK(1, MPI_CONFIG_PAGETYPE_IO_UNIT, 0x02, "l",
 295                               0x41 /* single function, RAID disabled */ );
 296 }
 297
 298 static
 299 size_t mptsas_config_io_unit_2(MPTSASState *s, uint8_t **data, int address)
 300 {
 301     PCIDevice *pci = PCI_DEVICE(s);
 302     uint8_t devfn = pci->devfn;
 303     return MPTSAS_CONFIG_PACK(2, MPI_CONFIG_PAGETYPE_IO_UNIT, 0x02,
 304                               "llbbw*b*b*w*b*b*w*b*b*w*l",
 305                               0, 0x100, 0 /* pci bus? */, devfn, 0);
 306 }
 307
 308 static
 309 size_t mptsas_config_io_unit_3(MPTSASState *s, uint8_t **data, int address)
 310 {
 311     return MPTSAS_CONFIG_PACK(3, MPI_CONFIG_PAGETYPE_IO_UNIT, 0x01,
 312                               "*b*b*w*l");
 313 }
 314
 315 static
 316 size_t mptsas_config_io_unit_4(MPTSASState *s, uint8_t **data, int address)
 317 {
 318     return MPTSAS_CONFIG_PACK(4, MPI_CONFIG_PAGETYPE_IO_UNIT, 0x00, "*l*l*q");
 319 }
 320
 321 /* I/O controller pages */
 322
 323 static
 324 size_t mptsas_config_ioc_0(MPTSASState *s, uint8_t **data, int address)
 325 {
 326     PCIDeviceClass *pcic = PCI_DEVICE_GET_CLASS(s);
 327
 328     return MPTSAS_CONFIG_PACK(0, MPI_CONFIG_PAGETYPE_IOC, 0x01,
 329                               "*l*lwwb*b*b*blww",
 330                               pcic->vendor_id, pcic->device_id, pcic->revision,
 331                               pcic->class_id, pcic->subsystem_vendor_id,
 332                               pcic->subsystem_id);
 333 }
 334
 335 static
 336 size_t mptsas_config_ioc_1(MPTSASState *s, uint8_t **data, int address)
 337 {
 338     return MPTSAS_CONFIG_PACK(1, MPI_CONFIG_PAGETYPE_IOC, 0x03,
 339                               "*l*l*b*b*b*b");
 340 }
 341
 342 static
 343 size_t mptsas_config_ioc_2(MPTSASState *s, uint8_t **data, int address)
 344 {
 345     return MPTSAS_CONFIG_PACK(2, MPI_CONFIG_PAGETYPE_IOC, 0x04,
 346                               "*l*b*b*b*b");
 347 }
 348
 349 static
 350 size_t mptsas_config_ioc_3(MPTSASState *s, uint8_t **data, int address)
 351 {
 352     return MPTSAS_CONFIG_PACK(3, MPI_CONFIG_PAGETYPE_IOC, 0x00,
 353                               "*b*b*w");
 354 }
 355
 356 static
 357 size_t mptsas_config_ioc_4(MPTSASState *s, uint8_t **data, int address)
 358 {
 359     return MPTSAS_CONFIG_PACK(4, MPI_CONFIG_PAGETYPE_IOC, 0x00,
 360                               "*b*b*w");
 361 }
 362
 363 static
 364 size_t mptsas_config_ioc_5(MPTSASState *s, uint8_t **data, int address)
 365 {
 366     return MPTSAS_CONFIG_PACK(5, MPI_CONFIG_PAGETYPE_IOC, 0x00,
 367                               "*l*b*b*w");
 368 }
 369
 370 static
 371 size_t mptsas_config_ioc_6(MPTSASState *s, uint8_t **data, int address)
 372 {
 373     return MPTSAS_CONFIG_PACK(6, MPI_CONFIG_PAGETYPE_IOC, 0x01,
 374                               "*l*b*b*b*b*b*b*b*b*b*b*w*l*l*l*l*b*b*w"
 375                               "*w*w*w*w*l*l*l");
 376 }
 377
 378 /* SAS I/O unit pages (extended) */
 379
 380 #define MPTSAS_CONFIG_SAS_IO_UNIT_0_SIZE 16
 381
 382 #define MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION 0x02
 383 #define MPI_SAS_IOUNIT0_RATE_1_5                      0x08
 384 #define MPI_SAS_IOUNIT0_RATE_3_0                      0x09
 385
 386 #define MPI_SAS_DEVICE_INFO_NO_DEVICE                 0x00000000
 387 #define MPI_SAS_DEVICE_INFO_END_DEVICE                0x00000001
 388 #define MPI_SAS_DEVICE_INFO_SSP_TARGET                0x00000400
 389
 390 #define MPI_SAS_DEVICE0_ASTATUS_NO_ERRORS             0x00
 391
 392 #define MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT          0x0001
 393 #define MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED           0x0002
 394 #define MPI_SAS_DEVICE0_FLAGS_MAPPING_PERSISTENT      0x0004
 395
 396
 397
 398 static SCSIDevice *mptsas_phy_get_device(MPTSASState *s, int i,
 399                                          int *phy_handle, int *dev_handle)
 400 {
 401     SCSIDevice *d = scsi_device_find(&s->bus, 0, i, 0);
 402
 403     if (phy_handle) {
 404         *phy_handle = i + 1;
 405     }
 406     if (dev_handle) {
 407         *dev_handle = d ? i + 1 + MPTSAS_NUM_PORTS : 0;
 408     }
 409     return d;
 410 }
 411
 412 static
 413 size_t mptsas_config_sas_io_unit_0(MPTSASState *s, uint8_t **data, int address)
 414 {
 415     size_t size = MPTSAS_CONFIG_PACK_EXT(0, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT, 0x04,
 416                                          "*w*wb*b*w"
 417                                          repl(MPTSAS_NUM_PORTS, "*s16"),
 418                                          MPTSAS_NUM_PORTS);
 419
 420     if (data) {
 421         size_t ofs = size - MPTSAS_NUM_PORTS * MPTSAS_CONFIG_SAS_IO_UNIT_0_SIZE;
 422         int i;
 423
 424         for (i = 0; i < MPTSAS_NUM_PORTS; i++) {
 425             int phy_handle, dev_handle;
 426             SCSIDevice *dev = mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
 427
 428             fill(*data + ofs, MPTSAS_CONFIG_SAS_IO_UNIT_0_SIZE,
 429                  "bbbblwwl", i, 0, 0,
 430                  (dev
 431                   ? MPI_SAS_IOUNIT0_RATE_3_0
 432                   : MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION),
 433                  (dev
 434                   ? MPI_SAS_DEVICE_INFO_END_DEVICE | MPI_SAS_DEVICE_INFO_SSP_TARGET
 435                   : MPI_SAS_DEVICE_INFO_NO_DEVICE),
 436                  dev_handle,
 437                  dev_handle,
 438                  0);
 439             ofs += MPTSAS_CONFIG_SAS_IO_UNIT_0_SIZE;
 440         }
 441         assert(ofs == size);
 442     }
 443     return size;
 444 }
 445
 446 #define MPTSAS_CONFIG_SAS_IO_UNIT_1_SIZE 12
 447
 448 static
 449 size_t mptsas_config_sas_io_unit_1(MPTSASState *s, uint8_t **data, int address)
 450 {
 451     size_t size = MPTSAS_CONFIG_PACK_EXT(1, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT, 0x07,
 452                                          "*w*w*w*wb*b*b*b"
 453                                          repl(MPTSAS_NUM_PORTS, "*s12"),
 454                                          MPTSAS_NUM_PORTS);
 455
 456     if (data) {
 457         size_t ofs = size - MPTSAS_NUM_PORTS * MPTSAS_CONFIG_SAS_IO_UNIT_1_SIZE;
 458         int i;
 459
 460         for (i = 0; i < MPTSAS_NUM_PORTS; i++) {
 461             SCSIDevice *dev = mptsas_phy_get_device(s, i, NULL, NULL);
 462             fill(*data + ofs, MPTSAS_CONFIG_SAS_IO_UNIT_1_SIZE,
 463                  "bbbblww", i, 0, 0,
 464                  (MPI_SAS_IOUNIT0_RATE_3_0 << 4) | MPI_SAS_IOUNIT0_RATE_1_5,
 465                  (dev
 466                   ? MPI_SAS_DEVICE_INFO_END_DEVICE | MPI_SAS_DEVICE_INFO_SSP_TARGET
 467                   : MPI_SAS_DEVICE_INFO_NO_DEVICE),
 468                  0, 0);
 469             ofs += MPTSAS_CONFIG_SAS_IO_UNIT_1_SIZE;
 470         }
 471         assert(ofs == size);
 472     }
 473     return size;
 474 }
 475
 476 static
 477 size_t mptsas_config_sas_io_unit_2(MPTSASState *s, uint8_t **data, int address)
 478 {
 479     return MPTSAS_CONFIG_PACK_EXT(2, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT, 0x06,
 480                                   "*b*b*w*w*w*b*b*w");
 481 }
 482
 483 static
 484 size_t mptsas_config_sas_io_unit_3(MPTSASState *s, uint8_t **data, int address)
 485 {
 486     return MPTSAS_CONFIG_PACK_EXT(3, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT, 0x06,
 487                                   "*l*l*l*l*l*l*l*l*l");
 488 }
 489
 490 /* SAS PHY pages (extended) */
 491
 492 static int mptsas_phy_addr_get(MPTSASState *s, int address)
 493 {
 494     int i;
 495     if ((address >> MPI_SAS_PHY_PGAD_FORM_SHIFT) == 0) {
 496         i = address & 255;
 497     } else if ((address >> MPI_SAS_PHY_PGAD_FORM_SHIFT) == 1) {
 498         i = address & 65535;
 499     } else {
 500         return -EINVAL;
 501     }
 502
 503     if (i >= MPTSAS_NUM_PORTS) {
 504         return -EINVAL;
 505     }
 506
 507     return i;
 508 }
 509
 510 static
 511 size_t mptsas_config_phy_0(MPTSASState *s, uint8_t **data, int address)
 512 {
 513     int phy_handle = -1;
 514     int dev_handle = -1;
 515     int i = mptsas_phy_addr_get(s, address);
 516     SCSIDevice *dev;
 517
 518     if (i < 0) {
 519         trace_mptsas_config_sas_phy(s, address, i, phy_handle, dev_handle, 0);
 520         return i;
 521     }
 522
 523     dev = mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
 524     trace_mptsas_config_sas_phy(s, address, i, phy_handle, dev_handle, 0);
 525
 526     return MPTSAS_CONFIG_PACK_EXT(0, MPI_CONFIG_EXTPAGETYPE_SAS_PHY, 0x01,
 527                                   "w*wqwb*blbb*b*b*l",
 528                                   dev_handle, s->sas_addr, dev_handle, i,
 529                                   (dev
 530                                    ? MPI_SAS_DEVICE_INFO_END_DEVICE /* | MPI_SAS_DEVICE_INFO_SSP_TARGET?? */
 531                                    : MPI_SAS_DEVICE_INFO_NO_DEVICE),
 532                                   (MPI_SAS_IOUNIT0_RATE_3_0 << 4) | MPI_SAS_IOUNIT0_RATE_1_5,
 533                                   (MPI_SAS_IOUNIT0_RATE_3_0 << 4) | MPI_SAS_IOUNIT0_RATE_1_5);
 534 }
 535
 536 static
 537 size_t mptsas_config_phy_1(MPTSASState *s, uint8_t **data, int address)
 538 {
 539     int phy_handle = -1;
 540     int dev_handle = -1;
 541     int i = mptsas_phy_addr_get(s, address);
 542
 543     if (i < 0) {
 544         trace_mptsas_config_sas_phy(s, address, i, phy_handle, dev_handle, 1);
 545         return i;
 546     }
 547
 548     (void) mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
 549     trace_mptsas_config_sas_phy(s, address, i, phy_handle, dev_handle, 1);
 550
 551     return MPTSAS_CONFIG_PACK_EXT(1, MPI_CONFIG_EXTPAGETYPE_SAS_PHY, 0x01,
 552                                   "*l*l*l*l*l");
 553 }
 554
 555 /* SAS device pages (extended) */
 556
 557 static int mptsas_device_addr_get(MPTSASState *s, int address)
 558 {
 559     uint32_t handle, i;
 560     uint32_t form = address >> MPI_SAS_PHY_PGAD_FORM_SHIFT;
 561     if (form == MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE) {
 562         handle = address & MPI_SAS_DEVICE_PGAD_GNH_HANDLE_MASK;
 563         do {
 564             if (handle == 65535) {
 565                 handle = MPTSAS_NUM_PORTS + 1;
 566             } else {
 567                 ++handle;
 568             }
 569             i = handle - 1 - MPTSAS_NUM_PORTS;
 570         } while (i < MPTSAS_NUM_PORTS && !scsi_device_find(&s->bus, 0, i, 0));
 571
 572     } else if (form == MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID) {
 573         if (address & MPI_SAS_DEVICE_PGAD_BT_BUS_MASK) {
 574             return -EINVAL;
 575         }
 576         i = address & MPI_SAS_DEVICE_PGAD_BT_TID_MASK;
 577
 578     } else if (form == MPI_SAS_DEVICE_PGAD_FORM_HANDLE) {
 579         handle = address & MPI_SAS_DEVICE_PGAD_H_HANDLE_MASK;
 580         i = handle - 1 - MPTSAS_NUM_PORTS;
 581
 582     } else {
 583         return -EINVAL;
 584     }
 585
 586     if (i >= MPTSAS_NUM_PORTS) {
 587         return -EINVAL;
 588     }
 589
 590     return i;
 591 }
 592
 593 static
 594 size_t mptsas_config_sas_device_0(MPTSASState *s, uint8_t **data, int address)
 595 {
 596     int phy_handle = -1;
 597     int dev_handle = -1;
 598     int i = mptsas_device_addr_get(s, address);
 599     SCSIDevice *dev = mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
 600
 601     trace_mptsas_config_sas_device(s, address, i, phy_handle, dev_handle, 0);
 602     if (!dev) {
 603         return -ENOENT;
 604     }
 605
 606     return MPTSAS_CONFIG_PACK_EXT(0, MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE, 0x05,
 607                                   "*w*wqwbbwbblwb*b",
 608                                   dev->wwn, phy_handle, i,
 609                                   MPI_SAS_DEVICE0_ASTATUS_NO_ERRORS,
 610                                   dev_handle, i, 0,
 611                                   MPI_SAS_DEVICE_INFO_END_DEVICE | MPI_SAS_DEVICE_INFO_SSP_TARGET,
 612                                   (MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT |
 613                                    MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED |
 614                                    MPI_SAS_DEVICE0_FLAGS_MAPPING_PERSISTENT), i);
 615 }
 616
 617 static
 618 size_t mptsas_config_sas_device_1(MPTSASState *s, uint8_t **data, int address)
 619 {
 620     int phy_handle = -1;
 621     int dev_handle = -1;
 622     int i = mptsas_device_addr_get(s, address);
 623     SCSIDevice *dev = mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
 624
 625     trace_mptsas_config_sas_device(s, address, i, phy_handle, dev_handle, 1);
 626     if (!dev) {
 627         return -ENOENT;
 628     }
 629
 630     return MPTSAS_CONFIG_PACK_EXT(1, MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE, 0x00,
 631                                   "*lq*lwbb*s20",
 632                                   dev->wwn, dev_handle, i, 0);
 633 }
 634
 635 static
 636 size_t mptsas_config_sas_device_2(MPTSASState *s, uint8_t **data, int address)
 637 {
 638     int phy_handle = -1;
 639     int dev_handle = -1;
 640     int i = mptsas_device_addr_get(s, address);
 641     SCSIDevice *dev = mptsas_phy_get_device(s, i, &phy_handle, &dev_handle);
 642
 643     trace_mptsas_config_sas_device(s, address, i, phy_handle, dev_handle, 2);
 644     if (!dev) {
 645         return -ENOENT;
 646     }
 647
 648     return MPTSAS_CONFIG_PACK_EXT(2, MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE, 0x01,
 649                                   "ql", dev->wwn, 0);
 650 }
 651
 652 typedef struct MPTSASConfigPage {
 653     uint8_t number;
 654     uint8_t type;
 655     size_t (*mpt_config_build)(MPTSASState *s, uint8_t **data, int address);
 656 } MPTSASConfigPage;
 657
 658 static const MPTSASConfigPage mptsas_config_pages[] = {
 659     {
 660         0, MPI_CONFIG_PAGETYPE_MANUFACTURING,
 661         mptsas_config_manufacturing_0,
 662     }, {
 663         1, MPI_CONFIG_PAGETYPE_MANUFACTURING,
 664         mptsas_config_manufacturing_1,
 665     }, {
 666         2, MPI_CONFIG_PAGETYPE_MANUFACTURING,
 667         mptsas_config_manufacturing_2,
 668     }, {
 669         3, MPI_CONFIG_PAGETYPE_MANUFACTURING,
 670         mptsas_config_manufacturing_3,
 671     }, {
 672         4, MPI_CONFIG_PAGETYPE_MANUFACTURING,
 673         mptsas_config_manufacturing_4,
 674     }, {
 675         5, MPI_CONFIG_PAGETYPE_MANUFACTURING,
 676         mptsas_config_manufacturing_5,
 677     }, {
 678         6, MPI_CONFIG_PAGETYPE_MANUFACTURING,
 679         mptsas_config_manufacturing_6,
 680     }, {
 681         7, MPI_CONFIG_PAGETYPE_MANUFACTURING,
 682         mptsas_config_manufacturing_7,
 683     }, {
 684         8, MPI_CONFIG_PAGETYPE_MANUFACTURING,
 685         mptsas_config_manufacturing_8,
 686     }, {
 687         9, MPI_CONFIG_PAGETYPE_MANUFACTURING,
 688         mptsas_config_manufacturing_9,
 689     }, {
 690         10, MPI_CONFIG_PAGETYPE_MANUFACTURING,
 691         mptsas_config_manufacturing_10,
 692     }, {
 693         0, MPI_CONFIG_PAGETYPE_IO_UNIT,
 694         mptsas_config_io_unit_0,
 695     }, {
 696         1, MPI_CONFIG_PAGETYPE_IO_UNIT,
 697         mptsas_config_io_unit_1,
 698     }, {
 699         2, MPI_CONFIG_PAGETYPE_IO_UNIT,
 700         mptsas_config_io_unit_2,
 701     }, {
 702         3, MPI_CONFIG_PAGETYPE_IO_UNIT,
 703         mptsas_config_io_unit_3,
 704     }, {
 705         4, MPI_CONFIG_PAGETYPE_IO_UNIT,
 706         mptsas_config_io_unit_4,
 707     }, {
 708         0, MPI_CONFIG_PAGETYPE_IOC,
 709         mptsas_config_ioc_0,
 710     }, {
 711         1, MPI_CONFIG_PAGETYPE_IOC,
 712         mptsas_config_ioc_1,
 713     }, {
 714         2, MPI_CONFIG_PAGETYPE_IOC,
 715         mptsas_config_ioc_2,
 716     }, {
 717         3, MPI_CONFIG_PAGETYPE_IOC,
 718         mptsas_config_ioc_3,
 719     }, {
 720         4, MPI_CONFIG_PAGETYPE_IOC,
 721         mptsas_config_ioc_4,
 722     }, {
 723         5, MPI_CONFIG_PAGETYPE_IOC,
 724         mptsas_config_ioc_5,
 725     }, {
 726         6, MPI_CONFIG_PAGETYPE_IOC,
 727         mptsas_config_ioc_6,
 728     }, {
 729         0, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT,
 730         mptsas_config_sas_io_unit_0,
 731     }, {
 732         1, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT,
 733         mptsas_config_sas_io_unit_1,
 734     }, {
 735         2, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT,
 736         mptsas_config_sas_io_unit_2,
 737     }, {
 738         3, MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT,
 739         mptsas_config_sas_io_unit_3,
 740     }, {
 741         0, MPI_CONFIG_EXTPAGETYPE_SAS_PHY,
 742         mptsas_config_phy_0,
 743     }, {
 744         1, MPI_CONFIG_EXTPAGETYPE_SAS_PHY,
 745         mptsas_config_phy_1,
 746     }, {
 747         0, MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE,
 748         mptsas_config_sas_device_0,
 749     }, {
 750         1, MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE,
 751         mptsas_config_sas_device_1,
 752     }, {
 753        2,  MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE,
 754         mptsas_config_sas_device_2,
 755     }
 756 };
 757
 758 static const MPTSASConfigPage *mptsas_find_config_page(int type, int number)
 759 {
 760     const MPTSASConfigPage *page;
 761     int i;
 762
 763     for (i = 0; i < ARRAY_SIZE(mptsas_config_pages); i++) {
 764         page = &mptsas_config_pages[i];
 765         if (page->type == type && page->number == number) {
 766             return page;
 767         }
 768     }
 769
 770     return NULL;
 771 }
 772
 773 void mptsas_process_config(MPTSASState *s, MPIMsgConfig *req)
 774 {
 775     PCIDevice *pci = PCI_DEVICE(s);
 776
 777     MPIMsgConfigReply reply;
 778     const MPTSASConfigPage *page;
 779     size_t length;
 780     uint8_t type;
 781     uint8_t *data = NULL;
 782     uint32_t flags_and_length;
 783     uint32_t dmalen;
 784     uint64_t pa;
 785
 786     mptsas_fix_config_endianness(req);
 787
 788     QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req));
 789     QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply));
 790
 791     /* Copy common bits from the request into the reply. */
 792     memset(&reply, 0, sizeof(reply));
 793     reply.Action      = req->Action;
 794     reply.Function    = req->Function;
 795     reply.MsgContext  = req->MsgContext;
 796     reply.MsgLength   = sizeof(reply) / 4;
 797     reply.PageType    = req->PageType;
 798     reply.PageNumber  = req->PageNumber;
 799     reply.PageLength  = req->PageLength;
 800     reply.PageVersion = req->PageVersion;
 801
 802     type = req->PageType & MPI_CONFIG_PAGETYPE_MASK;
 803     if (type == MPI_CONFIG_PAGETYPE_EXTENDED) {
 804         type = req->ExtPageType;
 805         if (type <= MPI_CONFIG_PAGETYPE_MASK) {
 806             reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_TYPE;
 807             goto out;
 808         }
 809
 810         reply.ExtPageType = req->ExtPageType;
 811     }
 812
 813     page = mptsas_find_config_page(type, req->PageNumber);
 814
 815     switch(req->Action) {
 816     case MPI_CONFIG_ACTION_PAGE_DEFAULT:
 817     case MPI_CONFIG_ACTION_PAGE_HEADER:
 818     case MPI_CONFIG_ACTION_PAGE_READ_NVRAM:
 819     case MPI_CONFIG_ACTION_PAGE_READ_CURRENT:
 820     case MPI_CONFIG_ACTION_PAGE_READ_DEFAULT:
 821     case MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT:
 822     case MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM:
 823         break;
 824
 825     default:
 826         reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_ACTION;
 827         goto out;
 828     }
 829
 830     if (!page) {
 831         page = mptsas_find_config_page(type, 1);
 832         if (page) {
 833             reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_PAGE;
 834         } else {
 835             reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_TYPE;
 836         }
 837         goto out;
 838     }
 839
 840     if (req->Action == MPI_CONFIG_ACTION_PAGE_DEFAULT ||
 841         req->Action == MPI_CONFIG_ACTION_PAGE_HEADER) {
 842         length = page->mpt_config_build(s, NULL, req->PageAddress);
 843         if ((ssize_t)length < 0) {
 844             reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_PAGE;
 845             goto out;
 846         } else {
 847             goto done;
 848         }
 849     }
 850
 851     if (req->Action == MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT ||
 852         req->Action == MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM) {
 853         length = page->mpt_config_build(s, NULL, req->PageAddress);
 854         if ((ssize_t)length < 0) {
 855             reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_PAGE;
 856         } else {
 857             reply.IOCStatus = MPI_IOCSTATUS_CONFIG_CANT_COMMIT;
 858         }
 859         goto out;
 860     }
 861
 862     flags_and_length = req->PageBufferSGE.FlagsLength;
 863     dmalen = flags_and_length & MPI_SGE_LENGTH_MASK;
 864     if (dmalen == 0) {
 865         length = page->mpt_config_build(s, NULL, req->PageAddress);
 866         if ((ssize_t)length < 0) {
 867             reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_PAGE;
 868             goto out;
 869         } else {
 870             goto done;
 871         }
 872     }
 873
 874     if (flags_and_length & MPI_SGE_FLAGS_64_BIT_ADDRESSING) {
 875         pa = req->PageBufferSGE.u.Address64;
 876     } else {
 877         pa = req->PageBufferSGE.u.Address32;
 878     }
 879
 880     /* Only read actions left.  */
 881     length = page->mpt_config_build(s, &data, req->PageAddress);
 882     if ((ssize_t)length < 0) {
 883         reply.IOCStatus = MPI_IOCSTATUS_CONFIG_INVALID_PAGE;
 884         goto out;
 885     } else {
 886         assert(data[2] == page->number);
 887         pci_dma_write(pci, pa, data, MIN(length, dmalen));
 888         goto done;
 889     }
 890
 891     abort();
 892
 893 done:
 894     if (type > MPI_CONFIG_PAGETYPE_MASK) {
 895         reply.ExtPageLength = length / 4;
 896         reply.ExtPageType   = req->ExtPageType;
 897     } else {
 898         reply.PageLength    = length / 4;
 899     }
 900
 901 out:
 902     mptsas_fix_config_reply_endianness(&reply);
 903     mptsas_reply(s, (MPIDefaultReply *)&reply);
 904     g_free(data);
 905 }