1 /* 2 * QEMU LSI SAS1068 Host Bus Adapter emulation 3 * Based on the QEMU Megaraid emulator 4 * 5 * Copyright (c) 2009-2012 Hannes Reinecke, SUSE Labs 6 * Copyright (c) 2012 Verizon, Inc. 7 * Copyright (c) 2016 Red Hat, Inc. 8 * 9 * Authors: Don Slutz, Paolo Bonzini 10 * 11 * This library is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU Lesser General Public 13 * License as published by the Free Software Foundation; either 14 * version 2 of the License, or (at your option) any later version. 15 * 16 * This library is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * Lesser General Public License for more details. 20 * 21 * You should have received a copy of the GNU Lesser General Public 22 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 23 */ 24 25 #include "qemu/osdep.h" 26 #include "hw/pci/pci.h" 27 #include "sysemu/dma.h" 28 #include "hw/pci/msi.h" 29 #include "qemu/iov.h" 30 #include "qemu/main-loop.h" 31 #include "qemu/module.h" 32 #include "hw/scsi/scsi.h" 33 #include "scsi/constants.h" 34 #include "trace.h" 35 #include "qapi/error.h" 36 #include "mptsas.h" 37 #include "migration/qemu-file-types.h" 38 #include "migration/vmstate.h" 39 #include "mpi.h" 40 41 #define NAA_LOCALLY_ASSIGNED_ID 0x3ULL 42 #define IEEE_COMPANY_LOCALLY_ASSIGNED 0x525400 43 44 #define TYPE_MPTSAS1068 "mptsas1068" 45 46 #define MPT_SAS(obj) \ 47 OBJECT_CHECK(MPTSASState, (obj), TYPE_MPTSAS1068) 48 49 #define MPTSAS1068_PRODUCT_ID \ 50 (MPI_FW_HEADER_PID_FAMILY_1068_SAS | \ 51 MPI_FW_HEADER_PID_PROD_INITIATOR_SCSI | \ 52 MPI_FW_HEADER_PID_TYPE_SAS) 53 54 struct MPTSASRequest { 55 MPIMsgSCSIIORequest scsi_io; 56 SCSIRequest *sreq; 57 QEMUSGList qsg; 58 MPTSASState *dev; 59 60 QTAILQ_ENTRY(MPTSASRequest) next; 61 }; 62 63 static void mptsas_update_interrupt(MPTSASState *s) 64 { 65 PCIDevice *pci = (PCIDevice *) s; 66 uint32_t state = s->intr_status & ~(s->intr_mask | MPI_HIS_IOP_DOORBELL_STATUS); 67 68 if (msi_enabled(pci)) { 69 if (state) { 70 trace_mptsas_irq_msi(s); 71 msi_notify(pci, 0); 72 } 73 } 74 75 trace_mptsas_irq_intx(s, !!state); 76 pci_set_irq(pci, !!state); 77 } 78 79 static void mptsas_set_fault(MPTSASState *s, uint32_t code) 80 { 81 if ((s->state & MPI_IOC_STATE_FAULT) == 0) { 82 s->state = MPI_IOC_STATE_FAULT | code; 83 } 84 } 85 86 #define MPTSAS_FIFO_INVALID(s, name) \ 87 ((s)->name##_head > ARRAY_SIZE((s)->name) || \ 88 (s)->name##_tail > ARRAY_SIZE((s)->name)) 89 90 #define MPTSAS_FIFO_EMPTY(s, name) \ 91 ((s)->name##_head == (s)->name##_tail) 92 93 #define MPTSAS_FIFO_FULL(s, name) \ 94 ((s)->name##_head == ((s)->name##_tail + 1) % ARRAY_SIZE((s)->name)) 95 96 #define MPTSAS_FIFO_GET(s, name) ({ \ 97 uint32_t _val = (s)->name[(s)->name##_head++]; \ 98 (s)->name##_head %= ARRAY_SIZE((s)->name); \ 99 _val; \ 100 }) 101 102 #define MPTSAS_FIFO_PUT(s, name, val) do { \ 103 (s)->name[(s)->name##_tail++] = (val); \ 104 (s)->name##_tail %= ARRAY_SIZE((s)->name); \ 105 } while(0) 106 107 static void mptsas_post_reply(MPTSASState *s, MPIDefaultReply *reply) 108 { 109 PCIDevice *pci = (PCIDevice *) s; 110 uint32_t addr_lo; 111 112 if (MPTSAS_FIFO_EMPTY(s, reply_free) || MPTSAS_FIFO_FULL(s, reply_post)) { 113 mptsas_set_fault(s, MPI_IOCSTATUS_INSUFFICIENT_RESOURCES); 114 return; 115 } 116 117 addr_lo = MPTSAS_FIFO_GET(s, reply_free); 118 119 pci_dma_write(pci, addr_lo | s->host_mfa_high_addr, reply, 120 MIN(s->reply_frame_size, 4 * reply->MsgLength)); 121 122 MPTSAS_FIFO_PUT(s, reply_post, MPI_ADDRESS_REPLY_A_BIT | (addr_lo >> 1)); 123 124 s->intr_status |= MPI_HIS_REPLY_MESSAGE_INTERRUPT; 125 if (s->doorbell_state == DOORBELL_WRITE) { 126 s->doorbell_state = DOORBELL_NONE; 127 s->intr_status |= MPI_HIS_DOORBELL_INTERRUPT; 128 } 129 mptsas_update_interrupt(s); 130 } 131 132 void mptsas_reply(MPTSASState *s, MPIDefaultReply *reply) 133 { 134 if (s->doorbell_state == DOORBELL_WRITE) { 135 /* The reply is sent out in 16 bit chunks, while the size 136 * in the reply is in 32 bit units. 137 */ 138 s->doorbell_state = DOORBELL_READ; 139 s->doorbell_reply_idx = 0; 140 s->doorbell_reply_size = reply->MsgLength * 2; 141 memcpy(s->doorbell_reply, reply, s->doorbell_reply_size * 2); 142 s->intr_status |= MPI_HIS_DOORBELL_INTERRUPT; 143 mptsas_update_interrupt(s); 144 } else { 145 mptsas_post_reply(s, reply); 146 } 147 } 148 149 static void mptsas_turbo_reply(MPTSASState *s, uint32_t msgctx) 150 { 151 if (MPTSAS_FIFO_FULL(s, reply_post)) { 152 mptsas_set_fault(s, MPI_IOCSTATUS_INSUFFICIENT_RESOURCES); 153 return; 154 } 155 156 /* The reply is just the message context ID (bit 31 = clear). */ 157 MPTSAS_FIFO_PUT(s, reply_post, msgctx); 158 159 s->intr_status |= MPI_HIS_REPLY_MESSAGE_INTERRUPT; 160 mptsas_update_interrupt(s); 161 } 162 163 #define MPTSAS_MAX_REQUEST_SIZE 52 164 165 static const int mpi_request_sizes[] = { 166 [MPI_FUNCTION_SCSI_IO_REQUEST] = sizeof(MPIMsgSCSIIORequest), 167 [MPI_FUNCTION_SCSI_TASK_MGMT] = sizeof(MPIMsgSCSITaskMgmt), 168 [MPI_FUNCTION_IOC_INIT] = sizeof(MPIMsgIOCInit), 169 [MPI_FUNCTION_IOC_FACTS] = sizeof(MPIMsgIOCFacts), 170 [MPI_FUNCTION_CONFIG] = sizeof(MPIMsgConfig), 171 [MPI_FUNCTION_PORT_FACTS] = sizeof(MPIMsgPortFacts), 172 [MPI_FUNCTION_PORT_ENABLE] = sizeof(MPIMsgPortEnable), 173 [MPI_FUNCTION_EVENT_NOTIFICATION] = sizeof(MPIMsgEventNotify), 174 }; 175 176 static dma_addr_t mptsas_ld_sg_base(MPTSASState *s, uint32_t flags_and_length, 177 dma_addr_t *sgaddr) 178 { 179 PCIDevice *pci = (PCIDevice *) s; 180 dma_addr_t addr; 181 182 if (flags_and_length & MPI_SGE_FLAGS_64_BIT_ADDRESSING) { 183 addr = ldq_le_pci_dma(pci, *sgaddr + 4); 184 *sgaddr += 12; 185 } else { 186 addr = ldl_le_pci_dma(pci, *sgaddr + 4); 187 *sgaddr += 8; 188 } 189 return addr; 190 } 191 192 static int mptsas_build_sgl(MPTSASState *s, MPTSASRequest *req, hwaddr addr) 193 { 194 PCIDevice *pci = (PCIDevice *) s; 195 hwaddr next_chain_addr; 196 uint32_t left; 197 hwaddr sgaddr; 198 uint32_t chain_offset; 199 200 chain_offset = req->scsi_io.ChainOffset; 201 next_chain_addr = addr + chain_offset * sizeof(uint32_t); 202 sgaddr = addr + sizeof(MPIMsgSCSIIORequest); 203 pci_dma_sglist_init(&req->qsg, pci, 4); 204 left = req->scsi_io.DataLength; 205 206 for(;;) { 207 dma_addr_t addr, len; 208 uint32_t flags_and_length; 209 210 flags_and_length = ldl_le_pci_dma(pci, sgaddr); 211 len = flags_and_length & MPI_SGE_LENGTH_MASK; 212 if ((flags_and_length & MPI_SGE_FLAGS_ELEMENT_TYPE_MASK) 213 != MPI_SGE_FLAGS_SIMPLE_ELEMENT || 214 (!len && 215 !(flags_and_length & MPI_SGE_FLAGS_END_OF_LIST) && 216 !(flags_and_length & MPI_SGE_FLAGS_END_OF_BUFFER))) { 217 return MPI_IOCSTATUS_INVALID_SGL; 218 } 219 220 len = MIN(len, left); 221 if (!len) { 222 /* We reached the desired transfer length, ignore extra 223 * elements of the s/g list. 224 */ 225 break; 226 } 227 228 addr = mptsas_ld_sg_base(s, flags_and_length, &sgaddr); 229 qemu_sglist_add(&req->qsg, addr, len); 230 left -= len; 231 232 if (flags_and_length & MPI_SGE_FLAGS_END_OF_LIST) { 233 break; 234 } 235 236 if (flags_and_length & MPI_SGE_FLAGS_LAST_ELEMENT) { 237 if (!chain_offset) { 238 break; 239 } 240 241 flags_and_length = ldl_le_pci_dma(pci, next_chain_addr); 242 if ((flags_and_length & MPI_SGE_FLAGS_ELEMENT_TYPE_MASK) 243 != MPI_SGE_FLAGS_CHAIN_ELEMENT) { 244 return MPI_IOCSTATUS_INVALID_SGL; 245 } 246 247 sgaddr = mptsas_ld_sg_base(s, flags_and_length, &next_chain_addr); 248 chain_offset = 249 (flags_and_length & MPI_SGE_CHAIN_OFFSET_MASK) >> MPI_SGE_CHAIN_OFFSET_SHIFT; 250 next_chain_addr = sgaddr + chain_offset * sizeof(uint32_t); 251 } 252 } 253 return 0; 254 } 255 256 static void mptsas_free_request(MPTSASRequest *req) 257 { 258 MPTSASState *s = req->dev; 259 260 if (req->sreq != NULL) { 261 req->sreq->hba_private = NULL; 262 scsi_req_unref(req->sreq); 263 req->sreq = NULL; 264 QTAILQ_REMOVE(&s->pending, req, next); 265 } 266 qemu_sglist_destroy(&req->qsg); 267 g_free(req); 268 } 269 270 static int mptsas_scsi_device_find(MPTSASState *s, int bus, int target, 271 uint8_t *lun, SCSIDevice **sdev) 272 { 273 if (bus != 0) { 274 return MPI_IOCSTATUS_SCSI_INVALID_BUS; 275 } 276 277 if (target >= s->max_devices) { 278 return MPI_IOCSTATUS_SCSI_INVALID_TARGETID; 279 } 280 281 *sdev = scsi_device_find(&s->bus, bus, target, lun[1]); 282 if (!*sdev) { 283 return MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE; 284 } 285 286 return 0; 287 } 288 289 static int mptsas_process_scsi_io_request(MPTSASState *s, 290 MPIMsgSCSIIORequest *scsi_io, 291 hwaddr addr) 292 { 293 MPTSASRequest *req; 294 MPIMsgSCSIIOReply reply; 295 SCSIDevice *sdev; 296 int status; 297 298 mptsas_fix_scsi_io_endianness(scsi_io); 299 300 trace_mptsas_process_scsi_io_request(s, scsi_io->Bus, scsi_io->TargetID, 301 scsi_io->LUN[1], scsi_io->DataLength); 302 303 status = mptsas_scsi_device_find(s, scsi_io->Bus, scsi_io->TargetID, 304 scsi_io->LUN, &sdev); 305 if (status) { 306 goto bad; 307 } 308 309 req = g_new0(MPTSASRequest, 1); 310 QTAILQ_INSERT_TAIL(&s->pending, req, next); 311 req->scsi_io = *scsi_io; 312 req->dev = s; 313 314 status = mptsas_build_sgl(s, req, addr); 315 if (status) { 316 goto free_bad; 317 } 318 319 if (req->qsg.size < scsi_io->DataLength) { 320 trace_mptsas_sgl_overflow(s, scsi_io->MsgContext, scsi_io->DataLength, 321 req->qsg.size); 322 status = MPI_IOCSTATUS_INVALID_SGL; 323 goto free_bad; 324 } 325 326 req->sreq = scsi_req_new(sdev, scsi_io->MsgContext, 327 scsi_io->LUN[1], scsi_io->CDB, req); 328 329 if (req->sreq->cmd.xfer > scsi_io->DataLength) { 330 goto overrun; 331 } 332 switch (scsi_io->Control & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK) { 333 case MPI_SCSIIO_CONTROL_NODATATRANSFER: 334 if (req->sreq->cmd.mode != SCSI_XFER_NONE) { 335 goto overrun; 336 } 337 break; 338 339 case MPI_SCSIIO_CONTROL_WRITE: 340 if (req->sreq->cmd.mode != SCSI_XFER_TO_DEV) { 341 goto overrun; 342 } 343 break; 344 345 case MPI_SCSIIO_CONTROL_READ: 346 if (req->sreq->cmd.mode != SCSI_XFER_FROM_DEV) { 347 goto overrun; 348 } 349 break; 350 } 351 352 if (scsi_req_enqueue(req->sreq)) { 353 scsi_req_continue(req->sreq); 354 } 355 return 0; 356 357 overrun: 358 trace_mptsas_scsi_overflow(s, scsi_io->MsgContext, req->sreq->cmd.xfer, 359 scsi_io->DataLength); 360 status = MPI_IOCSTATUS_SCSI_DATA_OVERRUN; 361 free_bad: 362 mptsas_free_request(req); 363 bad: 364 memset(&reply, 0, sizeof(reply)); 365 reply.TargetID = scsi_io->TargetID; 366 reply.Bus = scsi_io->Bus; 367 reply.MsgLength = sizeof(reply) / 4; 368 reply.Function = scsi_io->Function; 369 reply.CDBLength = scsi_io->CDBLength; 370 reply.SenseBufferLength = scsi_io->SenseBufferLength; 371 reply.MsgContext = scsi_io->MsgContext; 372 reply.SCSIState = MPI_SCSI_STATE_NO_SCSI_STATUS; 373 reply.IOCStatus = status; 374 375 mptsas_fix_scsi_io_reply_endianness(&reply); 376 mptsas_reply(s, (MPIDefaultReply *)&reply); 377 378 return 0; 379 } 380 381 typedef struct { 382 Notifier notifier; 383 MPTSASState *s; 384 MPIMsgSCSITaskMgmtReply *reply; 385 } MPTSASCancelNotifier; 386 387 static void mptsas_cancel_notify(Notifier *notifier, void *data) 388 { 389 MPTSASCancelNotifier *n = container_of(notifier, 390 MPTSASCancelNotifier, 391 notifier); 392 393 /* Abusing IOCLogInfo to store the expected number of requests... */ 394 if (++n->reply->TerminationCount == n->reply->IOCLogInfo) { 395 n->reply->IOCLogInfo = 0; 396 mptsas_fix_scsi_task_mgmt_reply_endianness(n->reply); 397 mptsas_post_reply(n->s, (MPIDefaultReply *)n->reply); 398 g_free(n->reply); 399 } 400 g_free(n); 401 } 402 403 static void mptsas_process_scsi_task_mgmt(MPTSASState *s, MPIMsgSCSITaskMgmt *req) 404 { 405 MPIMsgSCSITaskMgmtReply reply; 406 MPIMsgSCSITaskMgmtReply *reply_async; 407 int status, count; 408 SCSIDevice *sdev; 409 SCSIRequest *r, *next; 410 BusChild *kid; 411 412 mptsas_fix_scsi_task_mgmt_endianness(req); 413 414 QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req)); 415 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req)); 416 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply)); 417 418 memset(&reply, 0, sizeof(reply)); 419 reply.TargetID = req->TargetID; 420 reply.Bus = req->Bus; 421 reply.MsgLength = sizeof(reply) / 4; 422 reply.Function = req->Function; 423 reply.TaskType = req->TaskType; 424 reply.MsgContext = req->MsgContext; 425 426 switch (req->TaskType) { 427 case MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK: 428 case MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK: 429 status = mptsas_scsi_device_find(s, req->Bus, req->TargetID, 430 req->LUN, &sdev); 431 if (status) { 432 reply.IOCStatus = status; 433 goto out; 434 } 435 if (sdev->lun != req->LUN[1]) { 436 reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN; 437 goto out; 438 } 439 440 QTAILQ_FOREACH_SAFE(r, &sdev->requests, next, next) { 441 MPTSASRequest *cmd_req = r->hba_private; 442 if (cmd_req && cmd_req->scsi_io.MsgContext == req->TaskMsgContext) { 443 break; 444 } 445 } 446 if (r) { 447 /* 448 * Assert that the request has not been completed yet, we 449 * check for it in the loop above. 450 */ 451 assert(r->hba_private); 452 if (req->TaskType == MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK) { 453 /* "If the specified command is present in the task set, then 454 * return a service response set to FUNCTION SUCCEEDED". 455 */ 456 reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED; 457 } else { 458 MPTSASCancelNotifier *notifier; 459 460 reply_async = g_memdup(&reply, sizeof(MPIMsgSCSITaskMgmtReply)); 461 reply_async->IOCLogInfo = INT_MAX; 462 463 count = 1; 464 notifier = g_new(MPTSASCancelNotifier, 1); 465 notifier->s = s; 466 notifier->reply = reply_async; 467 notifier->notifier.notify = mptsas_cancel_notify; 468 scsi_req_cancel_async(r, ¬ifier->notifier); 469 goto reply_maybe_async; 470 } 471 } 472 break; 473 474 case MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET: 475 case MPI_SCSITASKMGMT_TASKTYPE_CLEAR_TASK_SET: 476 status = mptsas_scsi_device_find(s, req->Bus, req->TargetID, 477 req->LUN, &sdev); 478 if (status) { 479 reply.IOCStatus = status; 480 goto out; 481 } 482 if (sdev->lun != req->LUN[1]) { 483 reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN; 484 goto out; 485 } 486 487 reply_async = g_memdup(&reply, sizeof(MPIMsgSCSITaskMgmtReply)); 488 reply_async->IOCLogInfo = INT_MAX; 489 490 count = 0; 491 QTAILQ_FOREACH_SAFE(r, &sdev->requests, next, next) { 492 if (r->hba_private) { 493 MPTSASCancelNotifier *notifier; 494 495 count++; 496 notifier = g_new(MPTSASCancelNotifier, 1); 497 notifier->s = s; 498 notifier->reply = reply_async; 499 notifier->notifier.notify = mptsas_cancel_notify; 500 scsi_req_cancel_async(r, ¬ifier->notifier); 501 } 502 } 503 504 reply_maybe_async: 505 if (reply_async->TerminationCount < count) { 506 reply_async->IOCLogInfo = count; 507 return; 508 } 509 g_free(reply_async); 510 reply.TerminationCount = count; 511 break; 512 513 case MPI_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET: 514 status = mptsas_scsi_device_find(s, req->Bus, req->TargetID, 515 req->LUN, &sdev); 516 if (status) { 517 reply.IOCStatus = status; 518 goto out; 519 } 520 if (sdev->lun != req->LUN[1]) { 521 reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN; 522 goto out; 523 } 524 qdev_reset_all(&sdev->qdev); 525 break; 526 527 case MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET: 528 if (req->Bus != 0) { 529 reply.IOCStatus = MPI_IOCSTATUS_SCSI_INVALID_BUS; 530 goto out; 531 } 532 if (req->TargetID > s->max_devices) { 533 reply.IOCStatus = MPI_IOCSTATUS_SCSI_INVALID_TARGETID; 534 goto out; 535 } 536 537 QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) { 538 sdev = SCSI_DEVICE(kid->child); 539 if (sdev->channel == 0 && sdev->id == req->TargetID) { 540 qdev_reset_all(kid->child); 541 } 542 } 543 break; 544 545 case MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS: 546 qbus_reset_all(BUS(&s->bus)); 547 break; 548 549 default: 550 reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED; 551 break; 552 } 553 554 out: 555 mptsas_fix_scsi_task_mgmt_reply_endianness(&reply); 556 mptsas_post_reply(s, (MPIDefaultReply *)&reply); 557 } 558 559 static void mptsas_process_ioc_init(MPTSASState *s, MPIMsgIOCInit *req) 560 { 561 MPIMsgIOCInitReply reply; 562 563 mptsas_fix_ioc_init_endianness(req); 564 565 QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req)); 566 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req)); 567 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply)); 568 569 s->who_init = req->WhoInit; 570 s->reply_frame_size = req->ReplyFrameSize; 571 s->max_buses = req->MaxBuses; 572 s->max_devices = req->MaxDevices ? req->MaxDevices : 256; 573 s->host_mfa_high_addr = (hwaddr)req->HostMfaHighAddr << 32; 574 s->sense_buffer_high_addr = (hwaddr)req->SenseBufferHighAddr << 32; 575 576 if (s->state == MPI_IOC_STATE_READY) { 577 s->state = MPI_IOC_STATE_OPERATIONAL; 578 } 579 580 memset(&reply, 0, sizeof(reply)); 581 reply.WhoInit = s->who_init; 582 reply.MsgLength = sizeof(reply) / 4; 583 reply.Function = req->Function; 584 reply.MaxDevices = s->max_devices; 585 reply.MaxBuses = s->max_buses; 586 reply.MsgContext = req->MsgContext; 587 588 mptsas_fix_ioc_init_reply_endianness(&reply); 589 mptsas_reply(s, (MPIDefaultReply *)&reply); 590 } 591 592 static void mptsas_process_ioc_facts(MPTSASState *s, 593 MPIMsgIOCFacts *req) 594 { 595 MPIMsgIOCFactsReply reply; 596 597 mptsas_fix_ioc_facts_endianness(req); 598 599 QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req)); 600 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req)); 601 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply)); 602 603 memset(&reply, 0, sizeof(reply)); 604 reply.MsgVersion = 0x0105; 605 reply.MsgLength = sizeof(reply) / 4; 606 reply.Function = req->Function; 607 reply.MsgContext = req->MsgContext; 608 reply.MaxChainDepth = MPTSAS_MAXIMUM_CHAIN_DEPTH; 609 reply.WhoInit = s->who_init; 610 reply.BlockSize = MPTSAS_MAX_REQUEST_SIZE / sizeof(uint32_t); 611 reply.ReplyQueueDepth = ARRAY_SIZE(s->reply_post) - 1; 612 QEMU_BUILD_BUG_ON(ARRAY_SIZE(s->reply_post) != ARRAY_SIZE(s->reply_free)); 613 614 reply.RequestFrameSize = 128; 615 reply.ProductID = MPTSAS1068_PRODUCT_ID; 616 reply.CurrentHostMfaHighAddr = s->host_mfa_high_addr >> 32; 617 reply.GlobalCredits = ARRAY_SIZE(s->request_post) - 1; 618 reply.NumberOfPorts = MPTSAS_NUM_PORTS; 619 reply.CurrentSenseBufferHighAddr = s->sense_buffer_high_addr >> 32; 620 reply.CurReplyFrameSize = s->reply_frame_size; 621 reply.MaxDevices = s->max_devices; 622 reply.MaxBuses = s->max_buses; 623 reply.FWVersionDev = 0; 624 reply.FWVersionUnit = 0x92; 625 reply.FWVersionMinor = 0x32; 626 reply.FWVersionMajor = 0x1; 627 628 mptsas_fix_ioc_facts_reply_endianness(&reply); 629 mptsas_reply(s, (MPIDefaultReply *)&reply); 630 } 631 632 static void mptsas_process_port_facts(MPTSASState *s, 633 MPIMsgPortFacts *req) 634 { 635 MPIMsgPortFactsReply reply; 636 637 mptsas_fix_port_facts_endianness(req); 638 639 QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req)); 640 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req)); 641 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply)); 642 643 memset(&reply, 0, sizeof(reply)); 644 reply.MsgLength = sizeof(reply) / 4; 645 reply.Function = req->Function; 646 reply.PortNumber = req->PortNumber; 647 reply.MsgContext = req->MsgContext; 648 649 if (req->PortNumber < MPTSAS_NUM_PORTS) { 650 reply.PortType = MPI_PORTFACTS_PORTTYPE_SAS; 651 reply.MaxDevices = MPTSAS_NUM_PORTS; 652 reply.PortSCSIID = MPTSAS_NUM_PORTS; 653 reply.ProtocolFlags = MPI_PORTFACTS_PROTOCOL_LOGBUSADDR | MPI_PORTFACTS_PROTOCOL_INITIATOR; 654 } 655 656 mptsas_fix_port_facts_reply_endianness(&reply); 657 mptsas_reply(s, (MPIDefaultReply *)&reply); 658 } 659 660 static void mptsas_process_port_enable(MPTSASState *s, 661 MPIMsgPortEnable *req) 662 { 663 MPIMsgPortEnableReply reply; 664 665 mptsas_fix_port_enable_endianness(req); 666 667 QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req)); 668 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req)); 669 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply)); 670 671 memset(&reply, 0, sizeof(reply)); 672 reply.MsgLength = sizeof(reply) / 4; 673 reply.PortNumber = req->PortNumber; 674 reply.Function = req->Function; 675 reply.MsgContext = req->MsgContext; 676 677 mptsas_fix_port_enable_reply_endianness(&reply); 678 mptsas_reply(s, (MPIDefaultReply *)&reply); 679 } 680 681 static void mptsas_process_event_notification(MPTSASState *s, 682 MPIMsgEventNotify *req) 683 { 684 MPIMsgEventNotifyReply reply; 685 686 mptsas_fix_event_notification_endianness(req); 687 688 QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req)); 689 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req)); 690 QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply)); 691 692 /* Don't even bother storing whether event notification is enabled, 693 * since it is not accessible. 694 */ 695 696 memset(&reply, 0, sizeof(reply)); 697 reply.EventDataLength = sizeof(reply.Data) / 4; 698 reply.MsgLength = sizeof(reply) / 4; 699 reply.Function = req->Function; 700 701 /* This is set because events are sent through the reply FIFOs. */ 702 reply.MsgFlags = MPI_MSGFLAGS_CONTINUATION_REPLY; 703 704 reply.MsgContext = req->MsgContext; 705 reply.Event = MPI_EVENT_EVENT_CHANGE; 706 reply.Data[0] = !!req->Switch; 707 708 mptsas_fix_event_notification_reply_endianness(&reply); 709 mptsas_reply(s, (MPIDefaultReply *)&reply); 710 } 711 712 static void mptsas_process_message(MPTSASState *s, MPIRequestHeader *req) 713 { 714 trace_mptsas_process_message(s, req->Function, req->MsgContext); 715 switch (req->Function) { 716 case MPI_FUNCTION_SCSI_TASK_MGMT: 717 mptsas_process_scsi_task_mgmt(s, (MPIMsgSCSITaskMgmt *)req); 718 break; 719 720 case MPI_FUNCTION_IOC_INIT: 721 mptsas_process_ioc_init(s, (MPIMsgIOCInit *)req); 722 break; 723 724 case MPI_FUNCTION_IOC_FACTS: 725 mptsas_process_ioc_facts(s, (MPIMsgIOCFacts *)req); 726 break; 727 728 case MPI_FUNCTION_PORT_FACTS: 729 mptsas_process_port_facts(s, (MPIMsgPortFacts *)req); 730 break; 731 732 case MPI_FUNCTION_PORT_ENABLE: 733 mptsas_process_port_enable(s, (MPIMsgPortEnable *)req); 734 break; 735 736 case MPI_FUNCTION_EVENT_NOTIFICATION: 737 mptsas_process_event_notification(s, (MPIMsgEventNotify *)req); 738 break; 739 740 case MPI_FUNCTION_CONFIG: 741 mptsas_process_config(s, (MPIMsgConfig *)req); 742 break; 743 744 default: 745 trace_mptsas_unhandled_cmd(s, req->Function, 0); 746 mptsas_set_fault(s, MPI_IOCSTATUS_INVALID_FUNCTION); 747 break; 748 } 749 } 750 751 static void mptsas_fetch_request(MPTSASState *s) 752 { 753 PCIDevice *pci = (PCIDevice *) s; 754 char req[MPTSAS_MAX_REQUEST_SIZE]; 755 MPIRequestHeader *hdr = (MPIRequestHeader *)req; 756 hwaddr addr; 757 int size; 758 759 /* Read the message header from the guest first. */ 760 addr = s->host_mfa_high_addr | MPTSAS_FIFO_GET(s, request_post); 761 pci_dma_read(pci, addr, req, sizeof(*hdr)); 762 763 if (hdr->Function < ARRAY_SIZE(mpi_request_sizes) && 764 mpi_request_sizes[hdr->Function]) { 765 /* Read the rest of the request based on the type. Do not 766 * reread everything, as that could cause a TOC/TOU mismatch 767 * and leak data from the QEMU stack. 768 */ 769 size = mpi_request_sizes[hdr->Function]; 770 assert(size <= MPTSAS_MAX_REQUEST_SIZE); 771 pci_dma_read(pci, addr + sizeof(*hdr), &req[sizeof(*hdr)], 772 size - sizeof(*hdr)); 773 } 774 775 if (hdr->Function == MPI_FUNCTION_SCSI_IO_REQUEST) { 776 /* SCSI I/O requests are separate from mptsas_process_message 777 * because they cannot be sent through the doorbell yet. 778 */ 779 mptsas_process_scsi_io_request(s, (MPIMsgSCSIIORequest *)req, addr); 780 } else { 781 mptsas_process_message(s, (MPIRequestHeader *)req); 782 } 783 } 784 785 static void mptsas_fetch_requests(void *opaque) 786 { 787 MPTSASState *s = opaque; 788 789 if (s->state != MPI_IOC_STATE_OPERATIONAL) { 790 mptsas_set_fault(s, MPI_IOCSTATUS_INVALID_STATE); 791 return; 792 } 793 while (!MPTSAS_FIFO_EMPTY(s, request_post)) { 794 mptsas_fetch_request(s); 795 } 796 } 797 798 static void mptsas_soft_reset(MPTSASState *s) 799 { 800 uint32_t save_mask; 801 802 trace_mptsas_reset(s); 803 804 /* Temporarily disable interrupts */ 805 save_mask = s->intr_mask; 806 s->intr_mask = MPI_HIM_DIM | MPI_HIM_RIM; 807 mptsas_update_interrupt(s); 808 809 qbus_reset_all(BUS(&s->bus)); 810 s->intr_status = 0; 811 s->intr_mask = save_mask; 812 813 s->reply_free_tail = 0; 814 s->reply_free_head = 0; 815 s->reply_post_tail = 0; 816 s->reply_post_head = 0; 817 s->request_post_tail = 0; 818 s->request_post_head = 0; 819 qemu_bh_cancel(s->request_bh); 820 821 s->state = MPI_IOC_STATE_READY; 822 } 823 824 static uint32_t mptsas_doorbell_read(MPTSASState *s) 825 { 826 uint32_t ret; 827 828 ret = (s->who_init << MPI_DOORBELL_WHO_INIT_SHIFT) & MPI_DOORBELL_WHO_INIT_MASK; 829 ret |= s->state; 830 switch (s->doorbell_state) { 831 case DOORBELL_NONE: 832 break; 833 834 case DOORBELL_WRITE: 835 ret |= MPI_DOORBELL_ACTIVE; 836 break; 837 838 case DOORBELL_READ: 839 /* Get rid of the IOC fault code. */ 840 ret &= ~MPI_DOORBELL_DATA_MASK; 841 842 assert(s->intr_status & MPI_HIS_DOORBELL_INTERRUPT); 843 assert(s->doorbell_reply_idx <= s->doorbell_reply_size); 844 845 ret |= MPI_DOORBELL_ACTIVE; 846 if (s->doorbell_reply_idx < s->doorbell_reply_size) { 847 /* For more information about this endian switch, see the 848 * commit message for commit 36b62ae ("fw_cfg: fix endianness in 849 * fw_cfg_data_mem_read() / _write()", 2015-01-16). 850 */ 851 ret |= le16_to_cpu(s->doorbell_reply[s->doorbell_reply_idx++]); 852 } 853 break; 854 855 default: 856 abort(); 857 } 858 859 return ret; 860 } 861 862 static void mptsas_doorbell_write(MPTSASState *s, uint32_t val) 863 { 864 if (s->doorbell_state == DOORBELL_WRITE) { 865 if (s->doorbell_idx < s->doorbell_cnt) { 866 /* For more information about this endian switch, see the 867 * commit message for commit 36b62ae ("fw_cfg: fix endianness in 868 * fw_cfg_data_mem_read() / _write()", 2015-01-16). 869 */ 870 s->doorbell_msg[s->doorbell_idx++] = cpu_to_le32(val); 871 if (s->doorbell_idx == s->doorbell_cnt) { 872 mptsas_process_message(s, (MPIRequestHeader *)s->doorbell_msg); 873 } 874 } 875 return; 876 } 877 878 switch ((val & MPI_DOORBELL_FUNCTION_MASK) >> MPI_DOORBELL_FUNCTION_SHIFT) { 879 case MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET: 880 mptsas_soft_reset(s); 881 break; 882 case MPI_FUNCTION_IO_UNIT_RESET: 883 break; 884 case MPI_FUNCTION_HANDSHAKE: 885 s->doorbell_state = DOORBELL_WRITE; 886 s->doorbell_idx = 0; 887 s->doorbell_cnt = (val & MPI_DOORBELL_ADD_DWORDS_MASK) 888 >> MPI_DOORBELL_ADD_DWORDS_SHIFT; 889 s->intr_status |= MPI_HIS_DOORBELL_INTERRUPT; 890 mptsas_update_interrupt(s); 891 break; 892 default: 893 trace_mptsas_unhandled_doorbell_cmd(s, val); 894 break; 895 } 896 } 897 898 static void mptsas_write_sequence_write(MPTSASState *s, uint32_t val) 899 { 900 /* If the diagnostic register is enabled, any write to this register 901 * will disable it. Otherwise, the guest has to do a magic five-write 902 * sequence. 903 */ 904 if (s->diagnostic & MPI_DIAG_DRWE) { 905 goto disable; 906 } 907 908 switch (s->diagnostic_idx) { 909 case 0: 910 if ((val & MPI_WRSEQ_KEY_VALUE_MASK) != MPI_WRSEQ_1ST_KEY_VALUE) { 911 goto disable; 912 } 913 break; 914 case 1: 915 if ((val & MPI_WRSEQ_KEY_VALUE_MASK) != MPI_WRSEQ_2ND_KEY_VALUE) { 916 goto disable; 917 } 918 break; 919 case 2: 920 if ((val & MPI_WRSEQ_KEY_VALUE_MASK) != MPI_WRSEQ_3RD_KEY_VALUE) { 921 goto disable; 922 } 923 break; 924 case 3: 925 if ((val & MPI_WRSEQ_KEY_VALUE_MASK) != MPI_WRSEQ_4TH_KEY_VALUE) { 926 goto disable; 927 } 928 break; 929 case 4: 930 if ((val & MPI_WRSEQ_KEY_VALUE_MASK) != MPI_WRSEQ_5TH_KEY_VALUE) { 931 goto disable; 932 } 933 /* Prepare Spaceball One for departure, and change the 934 * combination on my luggage! 935 */ 936 s->diagnostic |= MPI_DIAG_DRWE; 937 break; 938 } 939 s->diagnostic_idx++; 940 return; 941 942 disable: 943 s->diagnostic &= ~MPI_DIAG_DRWE; 944 s->diagnostic_idx = 0; 945 } 946 947 static int mptsas_hard_reset(MPTSASState *s) 948 { 949 mptsas_soft_reset(s); 950 951 s->intr_mask = MPI_HIM_DIM | MPI_HIM_RIM; 952 953 s->host_mfa_high_addr = 0; 954 s->sense_buffer_high_addr = 0; 955 s->reply_frame_size = 0; 956 s->max_devices = MPTSAS_NUM_PORTS; 957 s->max_buses = 1; 958 959 return 0; 960 } 961 962 static void mptsas_interrupt_status_write(MPTSASState *s) 963 { 964 switch (s->doorbell_state) { 965 case DOORBELL_NONE: 966 case DOORBELL_WRITE: 967 s->intr_status &= ~MPI_HIS_DOORBELL_INTERRUPT; 968 break; 969 970 case DOORBELL_READ: 971 /* The reply can be read continuously, so leave the interrupt up. */ 972 assert(s->intr_status & MPI_HIS_DOORBELL_INTERRUPT); 973 if (s->doorbell_reply_idx == s->doorbell_reply_size) { 974 s->doorbell_state = DOORBELL_NONE; 975 } 976 break; 977 978 default: 979 abort(); 980 } 981 mptsas_update_interrupt(s); 982 } 983 984 static uint32_t mptsas_reply_post_read(MPTSASState *s) 985 { 986 uint32_t ret; 987 988 if (!MPTSAS_FIFO_EMPTY(s, reply_post)) { 989 ret = MPTSAS_FIFO_GET(s, reply_post); 990 } else { 991 ret = -1; 992 s->intr_status &= ~MPI_HIS_REPLY_MESSAGE_INTERRUPT; 993 mptsas_update_interrupt(s); 994 } 995 996 return ret; 997 } 998 999 static uint64_t mptsas_mmio_read(void *opaque, hwaddr addr, 1000 unsigned size) 1001 { 1002 MPTSASState *s = opaque; 1003 uint32_t ret = 0; 1004 1005 switch (addr & ~3) { 1006 case MPI_DOORBELL_OFFSET: 1007 ret = mptsas_doorbell_read(s); 1008 break; 1009 1010 case MPI_DIAGNOSTIC_OFFSET: 1011 ret = s->diagnostic; 1012 break; 1013 1014 case MPI_HOST_INTERRUPT_STATUS_OFFSET: 1015 ret = s->intr_status; 1016 break; 1017 1018 case MPI_HOST_INTERRUPT_MASK_OFFSET: 1019 ret = s->intr_mask; 1020 break; 1021 1022 case MPI_REPLY_POST_FIFO_OFFSET: 1023 ret = mptsas_reply_post_read(s); 1024 break; 1025 1026 default: 1027 trace_mptsas_mmio_unhandled_read(s, addr); 1028 break; 1029 } 1030 trace_mptsas_mmio_read(s, addr, ret); 1031 return ret; 1032 } 1033 1034 static void mptsas_mmio_write(void *opaque, hwaddr addr, 1035 uint64_t val, unsigned size) 1036 { 1037 MPTSASState *s = opaque; 1038 1039 trace_mptsas_mmio_write(s, addr, val); 1040 switch (addr) { 1041 case MPI_DOORBELL_OFFSET: 1042 mptsas_doorbell_write(s, val); 1043 break; 1044 1045 case MPI_WRITE_SEQUENCE_OFFSET: 1046 mptsas_write_sequence_write(s, val); 1047 break; 1048 1049 case MPI_DIAGNOSTIC_OFFSET: 1050 if (val & MPI_DIAG_RESET_ADAPTER) { 1051 mptsas_hard_reset(s); 1052 } 1053 break; 1054 1055 case MPI_HOST_INTERRUPT_STATUS_OFFSET: 1056 mptsas_interrupt_status_write(s); 1057 break; 1058 1059 case MPI_HOST_INTERRUPT_MASK_OFFSET: 1060 s->intr_mask = val & (MPI_HIM_RIM | MPI_HIM_DIM); 1061 mptsas_update_interrupt(s); 1062 break; 1063 1064 case MPI_REQUEST_POST_FIFO_OFFSET: 1065 if (MPTSAS_FIFO_FULL(s, request_post)) { 1066 mptsas_set_fault(s, MPI_IOCSTATUS_INSUFFICIENT_RESOURCES); 1067 } else { 1068 MPTSAS_FIFO_PUT(s, request_post, val & ~0x03); 1069 qemu_bh_schedule(s->request_bh); 1070 } 1071 break; 1072 1073 case MPI_REPLY_FREE_FIFO_OFFSET: 1074 if (MPTSAS_FIFO_FULL(s, reply_free)) { 1075 mptsas_set_fault(s, MPI_IOCSTATUS_INSUFFICIENT_RESOURCES); 1076 } else { 1077 MPTSAS_FIFO_PUT(s, reply_free, val); 1078 } 1079 break; 1080 1081 default: 1082 trace_mptsas_mmio_unhandled_write(s, addr, val); 1083 break; 1084 } 1085 } 1086 1087 static const MemoryRegionOps mptsas_mmio_ops = { 1088 .read = mptsas_mmio_read, 1089 .write = mptsas_mmio_write, 1090 .endianness = DEVICE_LITTLE_ENDIAN, 1091 .impl = { 1092 .min_access_size = 4, 1093 .max_access_size = 4, 1094 } 1095 }; 1096 1097 static const MemoryRegionOps mptsas_port_ops = { 1098 .read = mptsas_mmio_read, 1099 .write = mptsas_mmio_write, 1100 .endianness = DEVICE_LITTLE_ENDIAN, 1101 .impl = { 1102 .min_access_size = 4, 1103 .max_access_size = 4, 1104 } 1105 }; 1106 1107 static uint64_t mptsas_diag_read(void *opaque, hwaddr addr, 1108 unsigned size) 1109 { 1110 MPTSASState *s = opaque; 1111 trace_mptsas_diag_read(s, addr, 0); 1112 return 0; 1113 } 1114 1115 static void mptsas_diag_write(void *opaque, hwaddr addr, 1116 uint64_t val, unsigned size) 1117 { 1118 MPTSASState *s = opaque; 1119 trace_mptsas_diag_write(s, addr, val); 1120 } 1121 1122 static const MemoryRegionOps mptsas_diag_ops = { 1123 .read = mptsas_diag_read, 1124 .write = mptsas_diag_write, 1125 .endianness = DEVICE_LITTLE_ENDIAN, 1126 .impl = { 1127 .min_access_size = 4, 1128 .max_access_size = 4, 1129 } 1130 }; 1131 1132 static QEMUSGList *mptsas_get_sg_list(SCSIRequest *sreq) 1133 { 1134 MPTSASRequest *req = sreq->hba_private; 1135 1136 return &req->qsg; 1137 } 1138 1139 static void mptsas_command_complete(SCSIRequest *sreq, 1140 uint32_t status, size_t resid) 1141 { 1142 MPTSASRequest *req = sreq->hba_private; 1143 MPTSASState *s = req->dev; 1144 uint8_t sense_buf[SCSI_SENSE_BUF_SIZE]; 1145 uint8_t sense_len; 1146 1147 hwaddr sense_buffer_addr = req->dev->sense_buffer_high_addr | 1148 req->scsi_io.SenseBufferLowAddr; 1149 1150 trace_mptsas_command_complete(s, req->scsi_io.MsgContext, status, resid); 1151 1152 sense_len = scsi_req_get_sense(sreq, sense_buf, SCSI_SENSE_BUF_SIZE); 1153 if (sense_len > 0) { 1154 pci_dma_write(PCI_DEVICE(s), sense_buffer_addr, sense_buf, 1155 MIN(req->scsi_io.SenseBufferLength, sense_len)); 1156 } 1157 1158 if (sreq->status != GOOD || resid || 1159 req->dev->doorbell_state == DOORBELL_WRITE) { 1160 MPIMsgSCSIIOReply reply; 1161 1162 memset(&reply, 0, sizeof(reply)); 1163 reply.TargetID = req->scsi_io.TargetID; 1164 reply.Bus = req->scsi_io.Bus; 1165 reply.MsgLength = sizeof(reply) / 4; 1166 reply.Function = req->scsi_io.Function; 1167 reply.CDBLength = req->scsi_io.CDBLength; 1168 reply.SenseBufferLength = req->scsi_io.SenseBufferLength; 1169 reply.MsgFlags = req->scsi_io.MsgFlags; 1170 reply.MsgContext = req->scsi_io.MsgContext; 1171 reply.SCSIStatus = sreq->status; 1172 if (sreq->status == GOOD) { 1173 reply.TransferCount = req->scsi_io.DataLength - resid; 1174 if (resid) { 1175 reply.IOCStatus = MPI_IOCSTATUS_SCSI_DATA_UNDERRUN; 1176 } 1177 } else { 1178 reply.SCSIState = MPI_SCSI_STATE_AUTOSENSE_VALID; 1179 reply.SenseCount = sense_len; 1180 reply.IOCStatus = MPI_IOCSTATUS_SCSI_DATA_UNDERRUN; 1181 } 1182 1183 mptsas_fix_scsi_io_reply_endianness(&reply); 1184 mptsas_post_reply(req->dev, (MPIDefaultReply *)&reply); 1185 } else { 1186 mptsas_turbo_reply(req->dev, req->scsi_io.MsgContext); 1187 } 1188 1189 mptsas_free_request(req); 1190 } 1191 1192 static void mptsas_request_cancelled(SCSIRequest *sreq) 1193 { 1194 MPTSASRequest *req = sreq->hba_private; 1195 MPIMsgSCSIIOReply reply; 1196 1197 memset(&reply, 0, sizeof(reply)); 1198 reply.TargetID = req->scsi_io.TargetID; 1199 reply.Bus = req->scsi_io.Bus; 1200 reply.MsgLength = sizeof(reply) / 4; 1201 reply.Function = req->scsi_io.Function; 1202 reply.CDBLength = req->scsi_io.CDBLength; 1203 reply.SenseBufferLength = req->scsi_io.SenseBufferLength; 1204 reply.MsgFlags = req->scsi_io.MsgFlags; 1205 reply.MsgContext = req->scsi_io.MsgContext; 1206 reply.SCSIState = MPI_SCSI_STATE_NO_SCSI_STATUS; 1207 reply.IOCStatus = MPI_IOCSTATUS_SCSI_TASK_TERMINATED; 1208 1209 mptsas_fix_scsi_io_reply_endianness(&reply); 1210 mptsas_post_reply(req->dev, (MPIDefaultReply *)&reply); 1211 mptsas_free_request(req); 1212 } 1213 1214 static void mptsas_save_request(QEMUFile *f, SCSIRequest *sreq) 1215 { 1216 MPTSASRequest *req = sreq->hba_private; 1217 int i; 1218 1219 qemu_put_buffer(f, (unsigned char *)&req->scsi_io, sizeof(req->scsi_io)); 1220 qemu_put_be32(f, req->qsg.nsg); 1221 for (i = 0; i < req->qsg.nsg; i++) { 1222 qemu_put_be64(f, req->qsg.sg[i].base); 1223 qemu_put_be64(f, req->qsg.sg[i].len); 1224 } 1225 } 1226 1227 static void *mptsas_load_request(QEMUFile *f, SCSIRequest *sreq) 1228 { 1229 SCSIBus *bus = sreq->bus; 1230 MPTSASState *s = container_of(bus, MPTSASState, bus); 1231 PCIDevice *pci = PCI_DEVICE(s); 1232 MPTSASRequest *req; 1233 int i, n; 1234 1235 req = g_new(MPTSASRequest, 1); 1236 qemu_get_buffer(f, (unsigned char *)&req->scsi_io, sizeof(req->scsi_io)); 1237 1238 n = qemu_get_be32(f); 1239 /* TODO: add a way for SCSIBusInfo's load_request to fail, 1240 * and fail migration instead of asserting here. 1241 * This is just one thing (there are probably more) that must be 1242 * fixed before we can allow NDEBUG compilation. 1243 */ 1244 assert(n >= 0); 1245 1246 pci_dma_sglist_init(&req->qsg, pci, n); 1247 for (i = 0; i < n; i++) { 1248 uint64_t base = qemu_get_be64(f); 1249 uint64_t len = qemu_get_be64(f); 1250 qemu_sglist_add(&req->qsg, base, len); 1251 } 1252 1253 scsi_req_ref(sreq); 1254 req->sreq = sreq; 1255 req->dev = s; 1256 1257 return req; 1258 } 1259 1260 static const struct SCSIBusInfo mptsas_scsi_info = { 1261 .tcq = true, 1262 .max_target = MPTSAS_NUM_PORTS, 1263 .max_lun = 1, 1264 1265 .get_sg_list = mptsas_get_sg_list, 1266 .complete = mptsas_command_complete, 1267 .cancel = mptsas_request_cancelled, 1268 .save_request = mptsas_save_request, 1269 .load_request = mptsas_load_request, 1270 }; 1271 1272 static void mptsas_scsi_realize(PCIDevice *dev, Error **errp) 1273 { 1274 MPTSASState *s = MPT_SAS(dev); 1275 Error *err = NULL; 1276 int ret; 1277 1278 dev->config[PCI_LATENCY_TIMER] = 0; 1279 dev->config[PCI_INTERRUPT_PIN] = 0x01; 1280 1281 if (s->msi != ON_OFF_AUTO_OFF) { 1282 ret = msi_init(dev, 0, 1, true, false, &err); 1283 /* Any error other than -ENOTSUP(board's MSI support is broken) 1284 * is a programming error */ 1285 assert(!ret || ret == -ENOTSUP); 1286 if (ret && s->msi == ON_OFF_AUTO_ON) { 1287 /* Can't satisfy user's explicit msi=on request, fail */ 1288 error_append_hint(&err, "You have to use msi=auto (default) or " 1289 "msi=off with this machine type.\n"); 1290 error_propagate(errp, err); 1291 return; 1292 } 1293 assert(!err || s->msi == ON_OFF_AUTO_AUTO); 1294 /* With msi=auto, we fall back to MSI off silently */ 1295 error_free(err); 1296 1297 /* Only used for migration. */ 1298 s->msi_in_use = (ret == 0); 1299 } 1300 1301 memory_region_init_io(&s->mmio_io, OBJECT(s), &mptsas_mmio_ops, s, 1302 "mptsas-mmio", 0x4000); 1303 memory_region_init_io(&s->port_io, OBJECT(s), &mptsas_port_ops, s, 1304 "mptsas-io", 256); 1305 memory_region_init_io(&s->diag_io, OBJECT(s), &mptsas_diag_ops, s, 1306 "mptsas-diag", 0x10000); 1307 1308 pci_register_bar(dev, 0, PCI_BASE_ADDRESS_SPACE_IO, &s->port_io); 1309 pci_register_bar(dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY | 1310 PCI_BASE_ADDRESS_MEM_TYPE_32, &s->mmio_io); 1311 pci_register_bar(dev, 2, PCI_BASE_ADDRESS_SPACE_MEMORY | 1312 PCI_BASE_ADDRESS_MEM_TYPE_32, &s->diag_io); 1313 1314 if (!s->sas_addr) { 1315 s->sas_addr = ((NAA_LOCALLY_ASSIGNED_ID << 24) | 1316 IEEE_COMPANY_LOCALLY_ASSIGNED) << 36; 1317 s->sas_addr |= (pci_dev_bus_num(dev) << 16); 1318 s->sas_addr |= (PCI_SLOT(dev->devfn) << 8); 1319 s->sas_addr |= PCI_FUNC(dev->devfn); 1320 } 1321 s->max_devices = MPTSAS_NUM_PORTS; 1322 1323 s->request_bh = qemu_bh_new(mptsas_fetch_requests, s); 1324 1325 QTAILQ_INIT(&s->pending); 1326 1327 scsi_bus_new(&s->bus, sizeof(s->bus), &dev->qdev, &mptsas_scsi_info, NULL); 1328 } 1329 1330 static void mptsas_scsi_uninit(PCIDevice *dev) 1331 { 1332 MPTSASState *s = MPT_SAS(dev); 1333 1334 qemu_bh_delete(s->request_bh); 1335 msi_uninit(dev); 1336 } 1337 1338 static void mptsas_reset(DeviceState *dev) 1339 { 1340 MPTSASState *s = MPT_SAS(dev); 1341 1342 mptsas_hard_reset(s); 1343 } 1344 1345 static int mptsas_post_load(void *opaque, int version_id) 1346 { 1347 MPTSASState *s = opaque; 1348 1349 if (s->doorbell_idx > s->doorbell_cnt || 1350 s->doorbell_cnt > ARRAY_SIZE(s->doorbell_msg) || 1351 s->doorbell_reply_idx > s->doorbell_reply_size || 1352 s->doorbell_reply_size > ARRAY_SIZE(s->doorbell_reply) || 1353 MPTSAS_FIFO_INVALID(s, request_post) || 1354 MPTSAS_FIFO_INVALID(s, reply_post) || 1355 MPTSAS_FIFO_INVALID(s, reply_free) || 1356 s->diagnostic_idx > 4) { 1357 return -EINVAL; 1358 } 1359 1360 return 0; 1361 } 1362 1363 static const VMStateDescription vmstate_mptsas = { 1364 .name = "mptsas", 1365 .version_id = 0, 1366 .minimum_version_id = 0, 1367 .minimum_version_id_old = 0, 1368 .post_load = mptsas_post_load, 1369 .fields = (VMStateField[]) { 1370 VMSTATE_PCI_DEVICE(dev, MPTSASState), 1371 VMSTATE_BOOL(msi_in_use, MPTSASState), 1372 VMSTATE_UINT32(state, MPTSASState), 1373 VMSTATE_UINT8(who_init, MPTSASState), 1374 VMSTATE_UINT8(doorbell_state, MPTSASState), 1375 VMSTATE_UINT32_ARRAY(doorbell_msg, MPTSASState, 256), 1376 VMSTATE_INT32(doorbell_idx, MPTSASState), 1377 VMSTATE_INT32(doorbell_cnt, MPTSASState), 1378 1379 VMSTATE_UINT16_ARRAY(doorbell_reply, MPTSASState, 256), 1380 VMSTATE_INT32(doorbell_reply_idx, MPTSASState), 1381 VMSTATE_INT32(doorbell_reply_size, MPTSASState), 1382 1383 VMSTATE_UINT32(diagnostic, MPTSASState), 1384 VMSTATE_UINT8(diagnostic_idx, MPTSASState), 1385 1386 VMSTATE_UINT32(intr_status, MPTSASState), 1387 VMSTATE_UINT32(intr_mask, MPTSASState), 1388 1389 VMSTATE_UINT32_ARRAY(request_post, MPTSASState, 1390 MPTSAS_REQUEST_QUEUE_DEPTH + 1), 1391 VMSTATE_UINT16(request_post_head, MPTSASState), 1392 VMSTATE_UINT16(request_post_tail, MPTSASState), 1393 1394 VMSTATE_UINT32_ARRAY(reply_post, MPTSASState, 1395 MPTSAS_REPLY_QUEUE_DEPTH + 1), 1396 VMSTATE_UINT16(reply_post_head, MPTSASState), 1397 VMSTATE_UINT16(reply_post_tail, MPTSASState), 1398 1399 VMSTATE_UINT32_ARRAY(reply_free, MPTSASState, 1400 MPTSAS_REPLY_QUEUE_DEPTH + 1), 1401 VMSTATE_UINT16(reply_free_head, MPTSASState), 1402 VMSTATE_UINT16(reply_free_tail, MPTSASState), 1403 1404 VMSTATE_UINT16(max_buses, MPTSASState), 1405 VMSTATE_UINT16(max_devices, MPTSASState), 1406 VMSTATE_UINT16(reply_frame_size, MPTSASState), 1407 VMSTATE_UINT64(host_mfa_high_addr, MPTSASState), 1408 VMSTATE_UINT64(sense_buffer_high_addr, MPTSASState), 1409 VMSTATE_END_OF_LIST() 1410 } 1411 }; 1412 1413 static Property mptsas_properties[] = { 1414 DEFINE_PROP_UINT64("sas_address", MPTSASState, sas_addr, 0), 1415 /* TODO: test MSI support under Windows */ 1416 DEFINE_PROP_ON_OFF_AUTO("msi", MPTSASState, msi, ON_OFF_AUTO_AUTO), 1417 DEFINE_PROP_END_OF_LIST(), 1418 }; 1419 1420 static void mptsas1068_class_init(ObjectClass *oc, void *data) 1421 { 1422 DeviceClass *dc = DEVICE_CLASS(oc); 1423 PCIDeviceClass *pc = PCI_DEVICE_CLASS(oc); 1424 1425 pc->realize = mptsas_scsi_realize; 1426 pc->exit = mptsas_scsi_uninit; 1427 pc->romfile = 0; 1428 pc->vendor_id = PCI_VENDOR_ID_LSI_LOGIC; 1429 pc->device_id = PCI_DEVICE_ID_LSI_SAS1068; 1430 pc->subsystem_vendor_id = PCI_VENDOR_ID_LSI_LOGIC; 1431 pc->subsystem_id = 0x8000; 1432 pc->class_id = PCI_CLASS_STORAGE_SCSI; 1433 dc->props = mptsas_properties; 1434 dc->reset = mptsas_reset; 1435 dc->vmsd = &vmstate_mptsas; 1436 dc->desc = "LSI SAS 1068"; 1437 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1438 } 1439 1440 static const TypeInfo mptsas_info = { 1441 .name = TYPE_MPTSAS1068, 1442 .parent = TYPE_PCI_DEVICE, 1443 .instance_size = sizeof(MPTSASState), 1444 .class_init = mptsas1068_class_init, 1445 .interfaces = (InterfaceInfo[]) { 1446 { INTERFACE_CONVENTIONAL_PCI_DEVICE }, 1447 { }, 1448 }, 1449 }; 1450 1451 static void mptsas_register_types(void) 1452 { 1453 type_register(&mptsas_info); 1454 } 1455 1456 type_init(mptsas_register_types) 1457