1 /* 2 * Linux driver for VMware's para-virtualized SCSI HBA. 3 * 4 * Copyright (C) 2008-2014, VMware, Inc. All Rights Reserved. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the 8 * Free Software Foundation; version 2 of the License and no later version. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or 13 * NON INFRINGEMENT. See the GNU General Public License for more 14 * details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Maintained by: Arvind Kumar <arvindkumar@vmware.com> 21 * 22 */ 23 24 #include <linux/kernel.h> 25 #include <linux/module.h> 26 #include <linux/interrupt.h> 27 #include <linux/slab.h> 28 #include <linux/workqueue.h> 29 #include <linux/pci.h> 30 31 #include <scsi/scsi.h> 32 #include <scsi/scsi_host.h> 33 #include <scsi/scsi_cmnd.h> 34 #include <scsi/scsi_device.h> 35 #include <scsi/scsi_tcq.h> 36 37 #include "vmw_pvscsi.h" 38 39 #define PVSCSI_LINUX_DRIVER_DESC "VMware PVSCSI driver" 40 41 MODULE_DESCRIPTION(PVSCSI_LINUX_DRIVER_DESC); 42 MODULE_AUTHOR("VMware, Inc."); 43 MODULE_LICENSE("GPL"); 44 MODULE_VERSION(PVSCSI_DRIVER_VERSION_STRING); 45 46 #define PVSCSI_DEFAULT_NUM_PAGES_PER_RING 8 47 #define PVSCSI_DEFAULT_NUM_PAGES_MSG_RING 1 48 #define PVSCSI_DEFAULT_QUEUE_DEPTH 254 49 #define SGL_SIZE PAGE_SIZE 50 51 struct pvscsi_sg_list { 52 struct PVSCSISGElement sge[PVSCSI_MAX_NUM_SG_ENTRIES_PER_SEGMENT]; 53 }; 54 55 struct pvscsi_ctx { 56 /* 57 * The index of the context in cmd_map serves as the context ID for a 58 * 1-to-1 mapping completions back to requests. 59 */ 60 struct scsi_cmnd *cmd; 61 struct pvscsi_sg_list *sgl; 62 struct list_head list; 63 dma_addr_t dataPA; 64 dma_addr_t sensePA; 65 dma_addr_t sglPA; 66 struct completion *abort_cmp; 67 }; 68 69 struct pvscsi_adapter { 70 char *mmioBase; 71 unsigned int irq; 72 u8 rev; 73 bool use_msi; 74 bool use_msix; 75 bool use_msg; 76 bool use_req_threshold; 77 78 spinlock_t hw_lock; 79 80 struct workqueue_struct *workqueue; 81 struct work_struct work; 82 83 struct PVSCSIRingReqDesc *req_ring; 84 unsigned req_pages; 85 unsigned req_depth; 86 dma_addr_t reqRingPA; 87 88 struct PVSCSIRingCmpDesc *cmp_ring; 89 unsigned cmp_pages; 90 dma_addr_t cmpRingPA; 91 92 struct PVSCSIRingMsgDesc *msg_ring; 93 unsigned msg_pages; 94 dma_addr_t msgRingPA; 95 96 struct PVSCSIRingsState *rings_state; 97 dma_addr_t ringStatePA; 98 99 struct pci_dev *dev; 100 struct Scsi_Host *host; 101 102 struct list_head cmd_pool; 103 struct pvscsi_ctx *cmd_map; 104 }; 105 106 107 /* Command line parameters */ 108 static int pvscsi_ring_pages; 109 static int pvscsi_msg_ring_pages = PVSCSI_DEFAULT_NUM_PAGES_MSG_RING; 110 static int pvscsi_cmd_per_lun = PVSCSI_DEFAULT_QUEUE_DEPTH; 111 static bool pvscsi_disable_msi; 112 static bool pvscsi_disable_msix; 113 static bool pvscsi_use_msg = true; 114 static bool pvscsi_use_req_threshold = true; 115 116 #define PVSCSI_RW (S_IRUSR | S_IWUSR) 117 118 module_param_named(ring_pages, pvscsi_ring_pages, int, PVSCSI_RW); 119 MODULE_PARM_DESC(ring_pages, "Number of pages per req/cmp ring - (default=" 120 __stringify(PVSCSI_DEFAULT_NUM_PAGES_PER_RING) 121 "[up to 16 targets]," 122 __stringify(PVSCSI_SETUP_RINGS_MAX_NUM_PAGES) 123 "[for 16+ targets])"); 124 125 module_param_named(msg_ring_pages, pvscsi_msg_ring_pages, int, PVSCSI_RW); 126 MODULE_PARM_DESC(msg_ring_pages, "Number of pages for the msg ring - (default=" 127 __stringify(PVSCSI_DEFAULT_NUM_PAGES_MSG_RING) ")"); 128 129 module_param_named(cmd_per_lun, pvscsi_cmd_per_lun, int, PVSCSI_RW); 130 MODULE_PARM_DESC(cmd_per_lun, "Maximum commands per lun - (default=" 131 __stringify(PVSCSI_DEFAULT_QUEUE_DEPTH) ")"); 132 133 module_param_named(disable_msi, pvscsi_disable_msi, bool, PVSCSI_RW); 134 MODULE_PARM_DESC(disable_msi, "Disable MSI use in driver - (default=0)"); 135 136 module_param_named(disable_msix, pvscsi_disable_msix, bool, PVSCSI_RW); 137 MODULE_PARM_DESC(disable_msix, "Disable MSI-X use in driver - (default=0)"); 138 139 module_param_named(use_msg, pvscsi_use_msg, bool, PVSCSI_RW); 140 MODULE_PARM_DESC(use_msg, "Use msg ring when available - (default=1)"); 141 142 module_param_named(use_req_threshold, pvscsi_use_req_threshold, 143 bool, PVSCSI_RW); 144 MODULE_PARM_DESC(use_req_threshold, "Use driver-based request coalescing if configured - (default=1)"); 145 146 static const struct pci_device_id pvscsi_pci_tbl[] = { 147 { PCI_VDEVICE(VMWARE, PCI_DEVICE_ID_VMWARE_PVSCSI) }, 148 { 0 } 149 }; 150 151 MODULE_DEVICE_TABLE(pci, pvscsi_pci_tbl); 152 153 static struct device * 154 pvscsi_dev(const struct pvscsi_adapter *adapter) 155 { 156 return &(adapter->dev->dev); 157 } 158 159 static struct pvscsi_ctx * 160 pvscsi_find_context(const struct pvscsi_adapter *adapter, struct scsi_cmnd *cmd) 161 { 162 struct pvscsi_ctx *ctx, *end; 163 164 end = &adapter->cmd_map[adapter->req_depth]; 165 for (ctx = adapter->cmd_map; ctx < end; ctx++) 166 if (ctx->cmd == cmd) 167 return ctx; 168 169 return NULL; 170 } 171 172 static struct pvscsi_ctx * 173 pvscsi_acquire_context(struct pvscsi_adapter *adapter, struct scsi_cmnd *cmd) 174 { 175 struct pvscsi_ctx *ctx; 176 177 if (list_empty(&adapter->cmd_pool)) 178 return NULL; 179 180 ctx = list_first_entry(&adapter->cmd_pool, struct pvscsi_ctx, list); 181 ctx->cmd = cmd; 182 list_del(&ctx->list); 183 184 return ctx; 185 } 186 187 static void pvscsi_release_context(struct pvscsi_adapter *adapter, 188 struct pvscsi_ctx *ctx) 189 { 190 ctx->cmd = NULL; 191 ctx->abort_cmp = NULL; 192 list_add(&ctx->list, &adapter->cmd_pool); 193 } 194 195 /* 196 * Map a pvscsi_ctx struct to a context ID field value; we map to a simple 197 * non-zero integer. ctx always points to an entry in cmd_map array, hence 198 * the return value is always >=1. 199 */ 200 static u64 pvscsi_map_context(const struct pvscsi_adapter *adapter, 201 const struct pvscsi_ctx *ctx) 202 { 203 return ctx - adapter->cmd_map + 1; 204 } 205 206 static struct pvscsi_ctx * 207 pvscsi_get_context(const struct pvscsi_adapter *adapter, u64 context) 208 { 209 return &adapter->cmd_map[context - 1]; 210 } 211 212 static void pvscsi_reg_write(const struct pvscsi_adapter *adapter, 213 u32 offset, u32 val) 214 { 215 writel(val, adapter->mmioBase + offset); 216 } 217 218 static u32 pvscsi_reg_read(const struct pvscsi_adapter *adapter, u32 offset) 219 { 220 return readl(adapter->mmioBase + offset); 221 } 222 223 static u32 pvscsi_read_intr_status(const struct pvscsi_adapter *adapter) 224 { 225 return pvscsi_reg_read(adapter, PVSCSI_REG_OFFSET_INTR_STATUS); 226 } 227 228 static void pvscsi_write_intr_status(const struct pvscsi_adapter *adapter, 229 u32 val) 230 { 231 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_INTR_STATUS, val); 232 } 233 234 static void pvscsi_unmask_intr(const struct pvscsi_adapter *adapter) 235 { 236 u32 intr_bits; 237 238 intr_bits = PVSCSI_INTR_CMPL_MASK; 239 if (adapter->use_msg) 240 intr_bits |= PVSCSI_INTR_MSG_MASK; 241 242 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_INTR_MASK, intr_bits); 243 } 244 245 static void pvscsi_mask_intr(const struct pvscsi_adapter *adapter) 246 { 247 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_INTR_MASK, 0); 248 } 249 250 static void pvscsi_write_cmd_desc(const struct pvscsi_adapter *adapter, 251 u32 cmd, const void *desc, size_t len) 252 { 253 const u32 *ptr = desc; 254 size_t i; 255 256 len /= sizeof(*ptr); 257 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_COMMAND, cmd); 258 for (i = 0; i < len; i++) 259 pvscsi_reg_write(adapter, 260 PVSCSI_REG_OFFSET_COMMAND_DATA, ptr[i]); 261 } 262 263 static void pvscsi_abort_cmd(const struct pvscsi_adapter *adapter, 264 const struct pvscsi_ctx *ctx) 265 { 266 struct PVSCSICmdDescAbortCmd cmd = { 0 }; 267 268 cmd.target = ctx->cmd->device->id; 269 cmd.context = pvscsi_map_context(adapter, ctx); 270 271 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_ABORT_CMD, &cmd, sizeof(cmd)); 272 } 273 274 static void pvscsi_kick_rw_io(const struct pvscsi_adapter *adapter) 275 { 276 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_KICK_RW_IO, 0); 277 } 278 279 static void pvscsi_process_request_ring(const struct pvscsi_adapter *adapter) 280 { 281 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_KICK_NON_RW_IO, 0); 282 } 283 284 static int scsi_is_rw(unsigned char op) 285 { 286 return op == READ_6 || op == WRITE_6 || 287 op == READ_10 || op == WRITE_10 || 288 op == READ_12 || op == WRITE_12 || 289 op == READ_16 || op == WRITE_16; 290 } 291 292 static void pvscsi_kick_io(const struct pvscsi_adapter *adapter, 293 unsigned char op) 294 { 295 if (scsi_is_rw(op)) { 296 struct PVSCSIRingsState *s = adapter->rings_state; 297 298 if (!adapter->use_req_threshold || 299 s->reqProdIdx - s->reqConsIdx >= s->reqCallThreshold) 300 pvscsi_kick_rw_io(adapter); 301 } else { 302 pvscsi_process_request_ring(adapter); 303 } 304 } 305 306 static void ll_adapter_reset(const struct pvscsi_adapter *adapter) 307 { 308 dev_dbg(pvscsi_dev(adapter), "Adapter Reset on %p\n", adapter); 309 310 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_ADAPTER_RESET, NULL, 0); 311 } 312 313 static void ll_bus_reset(const struct pvscsi_adapter *adapter) 314 { 315 dev_dbg(pvscsi_dev(adapter), "Resetting bus on %p\n", adapter); 316 317 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_RESET_BUS, NULL, 0); 318 } 319 320 static void ll_device_reset(const struct pvscsi_adapter *adapter, u32 target) 321 { 322 struct PVSCSICmdDescResetDevice cmd = { 0 }; 323 324 dev_dbg(pvscsi_dev(adapter), "Resetting device: target=%u\n", target); 325 326 cmd.target = target; 327 328 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_RESET_DEVICE, 329 &cmd, sizeof(cmd)); 330 } 331 332 static void pvscsi_create_sg(struct pvscsi_ctx *ctx, 333 struct scatterlist *sg, unsigned count) 334 { 335 unsigned i; 336 struct PVSCSISGElement *sge; 337 338 BUG_ON(count > PVSCSI_MAX_NUM_SG_ENTRIES_PER_SEGMENT); 339 340 sge = &ctx->sgl->sge[0]; 341 for (i = 0; i < count; i++, sg++) { 342 sge[i].addr = sg_dma_address(sg); 343 sge[i].length = sg_dma_len(sg); 344 sge[i].flags = 0; 345 } 346 } 347 348 /* 349 * Map all data buffers for a command into PCI space and 350 * setup the scatter/gather list if needed. 351 */ 352 static void pvscsi_map_buffers(struct pvscsi_adapter *adapter, 353 struct pvscsi_ctx *ctx, struct scsi_cmnd *cmd, 354 struct PVSCSIRingReqDesc *e) 355 { 356 unsigned count; 357 unsigned bufflen = scsi_bufflen(cmd); 358 struct scatterlist *sg; 359 360 e->dataLen = bufflen; 361 e->dataAddr = 0; 362 if (bufflen == 0) 363 return; 364 365 sg = scsi_sglist(cmd); 366 count = scsi_sg_count(cmd); 367 if (count != 0) { 368 int segs = scsi_dma_map(cmd); 369 if (segs > 1) { 370 pvscsi_create_sg(ctx, sg, segs); 371 372 e->flags |= PVSCSI_FLAG_CMD_WITH_SG_LIST; 373 ctx->sglPA = pci_map_single(adapter->dev, ctx->sgl, 374 SGL_SIZE, PCI_DMA_TODEVICE); 375 e->dataAddr = ctx->sglPA; 376 } else 377 e->dataAddr = sg_dma_address(sg); 378 } else { 379 /* 380 * In case there is no S/G list, scsi_sglist points 381 * directly to the buffer. 382 */ 383 ctx->dataPA = pci_map_single(adapter->dev, sg, bufflen, 384 cmd->sc_data_direction); 385 e->dataAddr = ctx->dataPA; 386 } 387 } 388 389 static void pvscsi_unmap_buffers(const struct pvscsi_adapter *adapter, 390 struct pvscsi_ctx *ctx) 391 { 392 struct scsi_cmnd *cmd; 393 unsigned bufflen; 394 395 cmd = ctx->cmd; 396 bufflen = scsi_bufflen(cmd); 397 398 if (bufflen != 0) { 399 unsigned count = scsi_sg_count(cmd); 400 401 if (count != 0) { 402 scsi_dma_unmap(cmd); 403 if (ctx->sglPA) { 404 pci_unmap_single(adapter->dev, ctx->sglPA, 405 SGL_SIZE, PCI_DMA_TODEVICE); 406 ctx->sglPA = 0; 407 } 408 } else 409 pci_unmap_single(adapter->dev, ctx->dataPA, bufflen, 410 cmd->sc_data_direction); 411 } 412 if (cmd->sense_buffer) 413 pci_unmap_single(adapter->dev, ctx->sensePA, 414 SCSI_SENSE_BUFFERSIZE, PCI_DMA_FROMDEVICE); 415 } 416 417 static int pvscsi_allocate_rings(struct pvscsi_adapter *adapter) 418 { 419 adapter->rings_state = pci_alloc_consistent(adapter->dev, PAGE_SIZE, 420 &adapter->ringStatePA); 421 if (!adapter->rings_state) 422 return -ENOMEM; 423 424 adapter->req_pages = min(PVSCSI_MAX_NUM_PAGES_REQ_RING, 425 pvscsi_ring_pages); 426 adapter->req_depth = adapter->req_pages 427 * PVSCSI_MAX_NUM_REQ_ENTRIES_PER_PAGE; 428 adapter->req_ring = pci_alloc_consistent(adapter->dev, 429 adapter->req_pages * PAGE_SIZE, 430 &adapter->reqRingPA); 431 if (!adapter->req_ring) 432 return -ENOMEM; 433 434 adapter->cmp_pages = min(PVSCSI_MAX_NUM_PAGES_CMP_RING, 435 pvscsi_ring_pages); 436 adapter->cmp_ring = pci_alloc_consistent(adapter->dev, 437 adapter->cmp_pages * PAGE_SIZE, 438 &adapter->cmpRingPA); 439 if (!adapter->cmp_ring) 440 return -ENOMEM; 441 442 BUG_ON(!IS_ALIGNED(adapter->ringStatePA, PAGE_SIZE)); 443 BUG_ON(!IS_ALIGNED(adapter->reqRingPA, PAGE_SIZE)); 444 BUG_ON(!IS_ALIGNED(adapter->cmpRingPA, PAGE_SIZE)); 445 446 if (!adapter->use_msg) 447 return 0; 448 449 adapter->msg_pages = min(PVSCSI_MAX_NUM_PAGES_MSG_RING, 450 pvscsi_msg_ring_pages); 451 adapter->msg_ring = pci_alloc_consistent(adapter->dev, 452 adapter->msg_pages * PAGE_SIZE, 453 &adapter->msgRingPA); 454 if (!adapter->msg_ring) 455 return -ENOMEM; 456 BUG_ON(!IS_ALIGNED(adapter->msgRingPA, PAGE_SIZE)); 457 458 return 0; 459 } 460 461 static void pvscsi_setup_all_rings(const struct pvscsi_adapter *adapter) 462 { 463 struct PVSCSICmdDescSetupRings cmd = { 0 }; 464 dma_addr_t base; 465 unsigned i; 466 467 cmd.ringsStatePPN = adapter->ringStatePA >> PAGE_SHIFT; 468 cmd.reqRingNumPages = adapter->req_pages; 469 cmd.cmpRingNumPages = adapter->cmp_pages; 470 471 base = adapter->reqRingPA; 472 for (i = 0; i < adapter->req_pages; i++) { 473 cmd.reqRingPPNs[i] = base >> PAGE_SHIFT; 474 base += PAGE_SIZE; 475 } 476 477 base = adapter->cmpRingPA; 478 for (i = 0; i < adapter->cmp_pages; i++) { 479 cmd.cmpRingPPNs[i] = base >> PAGE_SHIFT; 480 base += PAGE_SIZE; 481 } 482 483 memset(adapter->rings_state, 0, PAGE_SIZE); 484 memset(adapter->req_ring, 0, adapter->req_pages * PAGE_SIZE); 485 memset(adapter->cmp_ring, 0, adapter->cmp_pages * PAGE_SIZE); 486 487 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_SETUP_RINGS, 488 &cmd, sizeof(cmd)); 489 490 if (adapter->use_msg) { 491 struct PVSCSICmdDescSetupMsgRing cmd_msg = { 0 }; 492 493 cmd_msg.numPages = adapter->msg_pages; 494 495 base = adapter->msgRingPA; 496 for (i = 0; i < adapter->msg_pages; i++) { 497 cmd_msg.ringPPNs[i] = base >> PAGE_SHIFT; 498 base += PAGE_SIZE; 499 } 500 memset(adapter->msg_ring, 0, adapter->msg_pages * PAGE_SIZE); 501 502 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_SETUP_MSG_RING, 503 &cmd_msg, sizeof(cmd_msg)); 504 } 505 } 506 507 static int pvscsi_change_queue_depth(struct scsi_device *sdev, 508 int qdepth, 509 int reason) 510 { 511 int max_depth; 512 struct Scsi_Host *shost = sdev->host; 513 514 if (reason != SCSI_QDEPTH_DEFAULT) 515 /* 516 * We support only changing default. 517 */ 518 return -EOPNOTSUPP; 519 520 max_depth = shost->can_queue; 521 if (!sdev->tagged_supported) 522 max_depth = 1; 523 if (qdepth > max_depth) 524 qdepth = max_depth; 525 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth); 526 527 if (sdev->inquiry_len > 7) 528 sdev_printk(KERN_INFO, sdev, 529 "qdepth(%d), tagged(%d), simple(%d), ordered(%d), scsi_level(%d), cmd_que(%d)\n", 530 sdev->queue_depth, sdev->tagged_supported, 531 sdev->simple_tags, sdev->ordered_tags, 532 sdev->scsi_level, (sdev->inquiry[7] & 2) >> 1); 533 return sdev->queue_depth; 534 } 535 536 /* 537 * Pull a completion descriptor off and pass the completion back 538 * to the SCSI mid layer. 539 */ 540 static void pvscsi_complete_request(struct pvscsi_adapter *adapter, 541 const struct PVSCSIRingCmpDesc *e) 542 { 543 struct pvscsi_ctx *ctx; 544 struct scsi_cmnd *cmd; 545 struct completion *abort_cmp; 546 u32 btstat = e->hostStatus; 547 u32 sdstat = e->scsiStatus; 548 549 ctx = pvscsi_get_context(adapter, e->context); 550 cmd = ctx->cmd; 551 abort_cmp = ctx->abort_cmp; 552 pvscsi_unmap_buffers(adapter, ctx); 553 pvscsi_release_context(adapter, ctx); 554 if (abort_cmp) { 555 /* 556 * The command was requested to be aborted. Just signal that 557 * the request completed and swallow the actual cmd completion 558 * here. The abort handler will post a completion for this 559 * command indicating that it got successfully aborted. 560 */ 561 complete(abort_cmp); 562 return; 563 } 564 565 cmd->result = 0; 566 if (sdstat != SAM_STAT_GOOD && 567 (btstat == BTSTAT_SUCCESS || 568 btstat == BTSTAT_LINKED_COMMAND_COMPLETED || 569 btstat == BTSTAT_LINKED_COMMAND_COMPLETED_WITH_FLAG)) { 570 cmd->result = (DID_OK << 16) | sdstat; 571 if (sdstat == SAM_STAT_CHECK_CONDITION && cmd->sense_buffer) 572 cmd->result |= (DRIVER_SENSE << 24); 573 } else 574 switch (btstat) { 575 case BTSTAT_SUCCESS: 576 case BTSTAT_LINKED_COMMAND_COMPLETED: 577 case BTSTAT_LINKED_COMMAND_COMPLETED_WITH_FLAG: 578 /* If everything went fine, let's move on.. */ 579 cmd->result = (DID_OK << 16); 580 break; 581 582 case BTSTAT_DATARUN: 583 case BTSTAT_DATA_UNDERRUN: 584 /* Report residual data in underruns */ 585 scsi_set_resid(cmd, scsi_bufflen(cmd) - e->dataLen); 586 cmd->result = (DID_ERROR << 16); 587 break; 588 589 case BTSTAT_SELTIMEO: 590 /* Our emulation returns this for non-connected devs */ 591 cmd->result = (DID_BAD_TARGET << 16); 592 break; 593 594 case BTSTAT_LUNMISMATCH: 595 case BTSTAT_TAGREJECT: 596 case BTSTAT_BADMSG: 597 cmd->result = (DRIVER_INVALID << 24); 598 /* fall through */ 599 600 case BTSTAT_HAHARDWARE: 601 case BTSTAT_INVPHASE: 602 case BTSTAT_HATIMEOUT: 603 case BTSTAT_NORESPONSE: 604 case BTSTAT_DISCONNECT: 605 case BTSTAT_HASOFTWARE: 606 case BTSTAT_BUSFREE: 607 case BTSTAT_SENSFAILED: 608 cmd->result |= (DID_ERROR << 16); 609 break; 610 611 case BTSTAT_SENTRST: 612 case BTSTAT_RECVRST: 613 case BTSTAT_BUSRESET: 614 cmd->result = (DID_RESET << 16); 615 break; 616 617 case BTSTAT_ABORTQUEUE: 618 cmd->result = (DID_ABORT << 16); 619 break; 620 621 case BTSTAT_SCSIPARITY: 622 cmd->result = (DID_PARITY << 16); 623 break; 624 625 default: 626 cmd->result = (DID_ERROR << 16); 627 scmd_printk(KERN_DEBUG, cmd, 628 "Unknown completion status: 0x%x\n", 629 btstat); 630 } 631 632 dev_dbg(&cmd->device->sdev_gendev, 633 "cmd=%p %x ctx=%p result=0x%x status=0x%x,%x\n", 634 cmd, cmd->cmnd[0], ctx, cmd->result, btstat, sdstat); 635 636 cmd->scsi_done(cmd); 637 } 638 639 /* 640 * barrier usage : Since the PVSCSI device is emulated, there could be cases 641 * where we may want to serialize some accesses between the driver and the 642 * emulation layer. We use compiler barriers instead of the more expensive 643 * memory barriers because PVSCSI is only supported on X86 which has strong 644 * memory access ordering. 645 */ 646 static void pvscsi_process_completion_ring(struct pvscsi_adapter *adapter) 647 { 648 struct PVSCSIRingsState *s = adapter->rings_state; 649 struct PVSCSIRingCmpDesc *ring = adapter->cmp_ring; 650 u32 cmp_entries = s->cmpNumEntriesLog2; 651 652 while (s->cmpConsIdx != s->cmpProdIdx) { 653 struct PVSCSIRingCmpDesc *e = ring + (s->cmpConsIdx & 654 MASK(cmp_entries)); 655 /* 656 * This barrier() ensures that *e is not dereferenced while 657 * the device emulation still writes data into the slot. 658 * Since the device emulation advances s->cmpProdIdx only after 659 * updating the slot we want to check it first. 660 */ 661 barrier(); 662 pvscsi_complete_request(adapter, e); 663 /* 664 * This barrier() ensures that compiler doesn't reorder write 665 * to s->cmpConsIdx before the read of (*e) inside 666 * pvscsi_complete_request. Otherwise, device emulation may 667 * overwrite *e before we had a chance to read it. 668 */ 669 barrier(); 670 s->cmpConsIdx++; 671 } 672 } 673 674 /* 675 * Translate a Linux SCSI request into a request ring entry. 676 */ 677 static int pvscsi_queue_ring(struct pvscsi_adapter *adapter, 678 struct pvscsi_ctx *ctx, struct scsi_cmnd *cmd) 679 { 680 struct PVSCSIRingsState *s; 681 struct PVSCSIRingReqDesc *e; 682 struct scsi_device *sdev; 683 u32 req_entries; 684 685 s = adapter->rings_state; 686 sdev = cmd->device; 687 req_entries = s->reqNumEntriesLog2; 688 689 /* 690 * If this condition holds, we might have room on the request ring, but 691 * we might not have room on the completion ring for the response. 692 * However, we have already ruled out this possibility - we would not 693 * have successfully allocated a context if it were true, since we only 694 * have one context per request entry. Check for it anyway, since it 695 * would be a serious bug. 696 */ 697 if (s->reqProdIdx - s->cmpConsIdx >= 1 << req_entries) { 698 scmd_printk(KERN_ERR, cmd, "vmw_pvscsi: " 699 "ring full: reqProdIdx=%d cmpConsIdx=%d\n", 700 s->reqProdIdx, s->cmpConsIdx); 701 return -1; 702 } 703 704 e = adapter->req_ring + (s->reqProdIdx & MASK(req_entries)); 705 706 e->bus = sdev->channel; 707 e->target = sdev->id; 708 memset(e->lun, 0, sizeof(e->lun)); 709 e->lun[1] = sdev->lun; 710 711 if (cmd->sense_buffer) { 712 ctx->sensePA = pci_map_single(adapter->dev, cmd->sense_buffer, 713 SCSI_SENSE_BUFFERSIZE, 714 PCI_DMA_FROMDEVICE); 715 e->senseAddr = ctx->sensePA; 716 e->senseLen = SCSI_SENSE_BUFFERSIZE; 717 } else { 718 e->senseLen = 0; 719 e->senseAddr = 0; 720 } 721 e->cdbLen = cmd->cmd_len; 722 e->vcpuHint = smp_processor_id(); 723 memcpy(e->cdb, cmd->cmnd, e->cdbLen); 724 725 e->tag = SIMPLE_QUEUE_TAG; 726 if (sdev->tagged_supported && 727 (cmd->tag == HEAD_OF_QUEUE_TAG || 728 cmd->tag == ORDERED_QUEUE_TAG)) 729 e->tag = cmd->tag; 730 731 if (cmd->sc_data_direction == DMA_FROM_DEVICE) 732 e->flags = PVSCSI_FLAG_CMD_DIR_TOHOST; 733 else if (cmd->sc_data_direction == DMA_TO_DEVICE) 734 e->flags = PVSCSI_FLAG_CMD_DIR_TODEVICE; 735 else if (cmd->sc_data_direction == DMA_NONE) 736 e->flags = PVSCSI_FLAG_CMD_DIR_NONE; 737 else 738 e->flags = 0; 739 740 pvscsi_map_buffers(adapter, ctx, cmd, e); 741 742 e->context = pvscsi_map_context(adapter, ctx); 743 744 barrier(); 745 746 s->reqProdIdx++; 747 748 return 0; 749 } 750 751 static int pvscsi_queue_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)) 752 { 753 struct Scsi_Host *host = cmd->device->host; 754 struct pvscsi_adapter *adapter = shost_priv(host); 755 struct pvscsi_ctx *ctx; 756 unsigned long flags; 757 758 spin_lock_irqsave(&adapter->hw_lock, flags); 759 760 ctx = pvscsi_acquire_context(adapter, cmd); 761 if (!ctx || pvscsi_queue_ring(adapter, ctx, cmd) != 0) { 762 if (ctx) 763 pvscsi_release_context(adapter, ctx); 764 spin_unlock_irqrestore(&adapter->hw_lock, flags); 765 return SCSI_MLQUEUE_HOST_BUSY; 766 } 767 768 cmd->scsi_done = done; 769 770 dev_dbg(&cmd->device->sdev_gendev, 771 "queued cmd %p, ctx %p, op=%x\n", cmd, ctx, cmd->cmnd[0]); 772 773 spin_unlock_irqrestore(&adapter->hw_lock, flags); 774 775 pvscsi_kick_io(adapter, cmd->cmnd[0]); 776 777 return 0; 778 } 779 780 static DEF_SCSI_QCMD(pvscsi_queue) 781 782 static int pvscsi_abort(struct scsi_cmnd *cmd) 783 { 784 struct pvscsi_adapter *adapter = shost_priv(cmd->device->host); 785 struct pvscsi_ctx *ctx; 786 unsigned long flags; 787 int result = SUCCESS; 788 DECLARE_COMPLETION_ONSTACK(abort_cmp); 789 790 scmd_printk(KERN_DEBUG, cmd, "task abort on host %u, %p\n", 791 adapter->host->host_no, cmd); 792 793 spin_lock_irqsave(&adapter->hw_lock, flags); 794 795 /* 796 * Poll the completion ring first - we might be trying to abort 797 * a command that is waiting to be dispatched in the completion ring. 798 */ 799 pvscsi_process_completion_ring(adapter); 800 801 /* 802 * If there is no context for the command, it either already succeeded 803 * or else was never properly issued. Not our problem. 804 */ 805 ctx = pvscsi_find_context(adapter, cmd); 806 if (!ctx) { 807 scmd_printk(KERN_DEBUG, cmd, "Failed to abort cmd %p\n", cmd); 808 goto out; 809 } 810 811 /* 812 * Mark that the command has been requested to be aborted and issue 813 * the abort. 814 */ 815 ctx->abort_cmp = &abort_cmp; 816 817 pvscsi_abort_cmd(adapter, ctx); 818 spin_unlock_irqrestore(&adapter->hw_lock, flags); 819 /* Wait for 2 secs for the completion. */ 820 wait_for_completion_timeout(&abort_cmp, msecs_to_jiffies(2000)); 821 spin_lock_irqsave(&adapter->hw_lock, flags); 822 823 if (!completion_done(&abort_cmp)) { 824 /* 825 * Failed to abort the command, unmark the fact that it 826 * was requested to be aborted. 827 */ 828 ctx->abort_cmp = NULL; 829 result = FAILED; 830 scmd_printk(KERN_DEBUG, cmd, 831 "Failed to get completion for aborted cmd %p\n", 832 cmd); 833 goto out; 834 } 835 836 /* 837 * Successfully aborted the command. 838 */ 839 cmd->result = (DID_ABORT << 16); 840 cmd->scsi_done(cmd); 841 842 out: 843 spin_unlock_irqrestore(&adapter->hw_lock, flags); 844 return result; 845 } 846 847 /* 848 * Abort all outstanding requests. This is only safe to use if the completion 849 * ring will never be walked again or the device has been reset, because it 850 * destroys the 1-1 mapping between context field passed to emulation and our 851 * request structure. 852 */ 853 static void pvscsi_reset_all(struct pvscsi_adapter *adapter) 854 { 855 unsigned i; 856 857 for (i = 0; i < adapter->req_depth; i++) { 858 struct pvscsi_ctx *ctx = &adapter->cmd_map[i]; 859 struct scsi_cmnd *cmd = ctx->cmd; 860 if (cmd) { 861 scmd_printk(KERN_ERR, cmd, 862 "Forced reset on cmd %p\n", cmd); 863 pvscsi_unmap_buffers(adapter, ctx); 864 pvscsi_release_context(adapter, ctx); 865 cmd->result = (DID_RESET << 16); 866 cmd->scsi_done(cmd); 867 } 868 } 869 } 870 871 static int pvscsi_host_reset(struct scsi_cmnd *cmd) 872 { 873 struct Scsi_Host *host = cmd->device->host; 874 struct pvscsi_adapter *adapter = shost_priv(host); 875 unsigned long flags; 876 bool use_msg; 877 878 scmd_printk(KERN_INFO, cmd, "SCSI Host reset\n"); 879 880 spin_lock_irqsave(&adapter->hw_lock, flags); 881 882 use_msg = adapter->use_msg; 883 884 if (use_msg) { 885 adapter->use_msg = 0; 886 spin_unlock_irqrestore(&adapter->hw_lock, flags); 887 888 /* 889 * Now that we know that the ISR won't add more work on the 890 * workqueue we can safely flush any outstanding work. 891 */ 892 flush_workqueue(adapter->workqueue); 893 spin_lock_irqsave(&adapter->hw_lock, flags); 894 } 895 896 /* 897 * We're going to tear down the entire ring structure and set it back 898 * up, so stalling new requests until all completions are flushed and 899 * the rings are back in place. 900 */ 901 902 pvscsi_process_request_ring(adapter); 903 904 ll_adapter_reset(adapter); 905 906 /* 907 * Now process any completions. Note we do this AFTER adapter reset, 908 * which is strange, but stops races where completions get posted 909 * between processing the ring and issuing the reset. The backend will 910 * not touch the ring memory after reset, so the immediately pre-reset 911 * completion ring state is still valid. 912 */ 913 pvscsi_process_completion_ring(adapter); 914 915 pvscsi_reset_all(adapter); 916 adapter->use_msg = use_msg; 917 pvscsi_setup_all_rings(adapter); 918 pvscsi_unmask_intr(adapter); 919 920 spin_unlock_irqrestore(&adapter->hw_lock, flags); 921 922 return SUCCESS; 923 } 924 925 static int pvscsi_bus_reset(struct scsi_cmnd *cmd) 926 { 927 struct Scsi_Host *host = cmd->device->host; 928 struct pvscsi_adapter *adapter = shost_priv(host); 929 unsigned long flags; 930 931 scmd_printk(KERN_INFO, cmd, "SCSI Bus reset\n"); 932 933 /* 934 * We don't want to queue new requests for this bus after 935 * flushing all pending requests to emulation, since new 936 * requests could then sneak in during this bus reset phase, 937 * so take the lock now. 938 */ 939 spin_lock_irqsave(&adapter->hw_lock, flags); 940 941 pvscsi_process_request_ring(adapter); 942 ll_bus_reset(adapter); 943 pvscsi_process_completion_ring(adapter); 944 945 spin_unlock_irqrestore(&adapter->hw_lock, flags); 946 947 return SUCCESS; 948 } 949 950 static int pvscsi_device_reset(struct scsi_cmnd *cmd) 951 { 952 struct Scsi_Host *host = cmd->device->host; 953 struct pvscsi_adapter *adapter = shost_priv(host); 954 unsigned long flags; 955 956 scmd_printk(KERN_INFO, cmd, "SCSI device reset on scsi%u:%u\n", 957 host->host_no, cmd->device->id); 958 959 /* 960 * We don't want to queue new requests for this device after flushing 961 * all pending requests to emulation, since new requests could then 962 * sneak in during this device reset phase, so take the lock now. 963 */ 964 spin_lock_irqsave(&adapter->hw_lock, flags); 965 966 pvscsi_process_request_ring(adapter); 967 ll_device_reset(adapter, cmd->device->id); 968 pvscsi_process_completion_ring(adapter); 969 970 spin_unlock_irqrestore(&adapter->hw_lock, flags); 971 972 return SUCCESS; 973 } 974 975 static struct scsi_host_template pvscsi_template; 976 977 static const char *pvscsi_info(struct Scsi_Host *host) 978 { 979 struct pvscsi_adapter *adapter = shost_priv(host); 980 static char buf[256]; 981 982 sprintf(buf, "VMware PVSCSI storage adapter rev %d, req/cmp/msg rings: " 983 "%u/%u/%u pages, cmd_per_lun=%u", adapter->rev, 984 adapter->req_pages, adapter->cmp_pages, adapter->msg_pages, 985 pvscsi_template.cmd_per_lun); 986 987 return buf; 988 } 989 990 static struct scsi_host_template pvscsi_template = { 991 .module = THIS_MODULE, 992 .name = "VMware PVSCSI Host Adapter", 993 .proc_name = "vmw_pvscsi", 994 .info = pvscsi_info, 995 .queuecommand = pvscsi_queue, 996 .this_id = -1, 997 .sg_tablesize = PVSCSI_MAX_NUM_SG_ENTRIES_PER_SEGMENT, 998 .dma_boundary = UINT_MAX, 999 .max_sectors = 0xffff, 1000 .use_clustering = ENABLE_CLUSTERING, 1001 .change_queue_depth = pvscsi_change_queue_depth, 1002 .eh_abort_handler = pvscsi_abort, 1003 .eh_device_reset_handler = pvscsi_device_reset, 1004 .eh_bus_reset_handler = pvscsi_bus_reset, 1005 .eh_host_reset_handler = pvscsi_host_reset, 1006 }; 1007 1008 static void pvscsi_process_msg(const struct pvscsi_adapter *adapter, 1009 const struct PVSCSIRingMsgDesc *e) 1010 { 1011 struct PVSCSIRingsState *s = adapter->rings_state; 1012 struct Scsi_Host *host = adapter->host; 1013 struct scsi_device *sdev; 1014 1015 printk(KERN_INFO "vmw_pvscsi: msg type: 0x%x - MSG RING: %u/%u (%u) \n", 1016 e->type, s->msgProdIdx, s->msgConsIdx, s->msgNumEntriesLog2); 1017 1018 BUILD_BUG_ON(PVSCSI_MSG_LAST != 2); 1019 1020 if (e->type == PVSCSI_MSG_DEV_ADDED) { 1021 struct PVSCSIMsgDescDevStatusChanged *desc; 1022 desc = (struct PVSCSIMsgDescDevStatusChanged *)e; 1023 1024 printk(KERN_INFO 1025 "vmw_pvscsi: msg: device added at scsi%u:%u:%u\n", 1026 desc->bus, desc->target, desc->lun[1]); 1027 1028 if (!scsi_host_get(host)) 1029 return; 1030 1031 sdev = scsi_device_lookup(host, desc->bus, desc->target, 1032 desc->lun[1]); 1033 if (sdev) { 1034 printk(KERN_INFO "vmw_pvscsi: device already exists\n"); 1035 scsi_device_put(sdev); 1036 } else 1037 scsi_add_device(adapter->host, desc->bus, 1038 desc->target, desc->lun[1]); 1039 1040 scsi_host_put(host); 1041 } else if (e->type == PVSCSI_MSG_DEV_REMOVED) { 1042 struct PVSCSIMsgDescDevStatusChanged *desc; 1043 desc = (struct PVSCSIMsgDescDevStatusChanged *)e; 1044 1045 printk(KERN_INFO 1046 "vmw_pvscsi: msg: device removed at scsi%u:%u:%u\n", 1047 desc->bus, desc->target, desc->lun[1]); 1048 1049 if (!scsi_host_get(host)) 1050 return; 1051 1052 sdev = scsi_device_lookup(host, desc->bus, desc->target, 1053 desc->lun[1]); 1054 if (sdev) { 1055 scsi_remove_device(sdev); 1056 scsi_device_put(sdev); 1057 } else 1058 printk(KERN_INFO 1059 "vmw_pvscsi: failed to lookup scsi%u:%u:%u\n", 1060 desc->bus, desc->target, desc->lun[1]); 1061 1062 scsi_host_put(host); 1063 } 1064 } 1065 1066 static int pvscsi_msg_pending(const struct pvscsi_adapter *adapter) 1067 { 1068 struct PVSCSIRingsState *s = adapter->rings_state; 1069 1070 return s->msgProdIdx != s->msgConsIdx; 1071 } 1072 1073 static void pvscsi_process_msg_ring(const struct pvscsi_adapter *adapter) 1074 { 1075 struct PVSCSIRingsState *s = adapter->rings_state; 1076 struct PVSCSIRingMsgDesc *ring = adapter->msg_ring; 1077 u32 msg_entries = s->msgNumEntriesLog2; 1078 1079 while (pvscsi_msg_pending(adapter)) { 1080 struct PVSCSIRingMsgDesc *e = ring + (s->msgConsIdx & 1081 MASK(msg_entries)); 1082 1083 barrier(); 1084 pvscsi_process_msg(adapter, e); 1085 barrier(); 1086 s->msgConsIdx++; 1087 } 1088 } 1089 1090 static void pvscsi_msg_workqueue_handler(struct work_struct *data) 1091 { 1092 struct pvscsi_adapter *adapter; 1093 1094 adapter = container_of(data, struct pvscsi_adapter, work); 1095 1096 pvscsi_process_msg_ring(adapter); 1097 } 1098 1099 static int pvscsi_setup_msg_workqueue(struct pvscsi_adapter *adapter) 1100 { 1101 char name[32]; 1102 1103 if (!pvscsi_use_msg) 1104 return 0; 1105 1106 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_COMMAND, 1107 PVSCSI_CMD_SETUP_MSG_RING); 1108 1109 if (pvscsi_reg_read(adapter, PVSCSI_REG_OFFSET_COMMAND_STATUS) == -1) 1110 return 0; 1111 1112 snprintf(name, sizeof(name), 1113 "vmw_pvscsi_wq_%u", adapter->host->host_no); 1114 1115 adapter->workqueue = create_singlethread_workqueue(name); 1116 if (!adapter->workqueue) { 1117 printk(KERN_ERR "vmw_pvscsi: failed to create work queue\n"); 1118 return 0; 1119 } 1120 INIT_WORK(&adapter->work, pvscsi_msg_workqueue_handler); 1121 1122 return 1; 1123 } 1124 1125 static bool pvscsi_setup_req_threshold(struct pvscsi_adapter *adapter, 1126 bool enable) 1127 { 1128 u32 val; 1129 1130 if (!pvscsi_use_req_threshold) 1131 return false; 1132 1133 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_COMMAND, 1134 PVSCSI_CMD_SETUP_REQCALLTHRESHOLD); 1135 val = pvscsi_reg_read(adapter, PVSCSI_REG_OFFSET_COMMAND_STATUS); 1136 if (val == -1) { 1137 printk(KERN_INFO "vmw_pvscsi: device does not support req_threshold\n"); 1138 return false; 1139 } else { 1140 struct PVSCSICmdDescSetupReqCall cmd_msg = { 0 }; 1141 cmd_msg.enable = enable; 1142 printk(KERN_INFO 1143 "vmw_pvscsi: %sabling reqCallThreshold\n", 1144 enable ? "en" : "dis"); 1145 pvscsi_write_cmd_desc(adapter, 1146 PVSCSI_CMD_SETUP_REQCALLTHRESHOLD, 1147 &cmd_msg, sizeof(cmd_msg)); 1148 return pvscsi_reg_read(adapter, 1149 PVSCSI_REG_OFFSET_COMMAND_STATUS) != 0; 1150 } 1151 } 1152 1153 static irqreturn_t pvscsi_isr(int irq, void *devp) 1154 { 1155 struct pvscsi_adapter *adapter = devp; 1156 int handled; 1157 1158 if (adapter->use_msi || adapter->use_msix) 1159 handled = true; 1160 else { 1161 u32 val = pvscsi_read_intr_status(adapter); 1162 handled = (val & PVSCSI_INTR_ALL_SUPPORTED) != 0; 1163 if (handled) 1164 pvscsi_write_intr_status(devp, val); 1165 } 1166 1167 if (handled) { 1168 unsigned long flags; 1169 1170 spin_lock_irqsave(&adapter->hw_lock, flags); 1171 1172 pvscsi_process_completion_ring(adapter); 1173 if (adapter->use_msg && pvscsi_msg_pending(adapter)) 1174 queue_work(adapter->workqueue, &adapter->work); 1175 1176 spin_unlock_irqrestore(&adapter->hw_lock, flags); 1177 } 1178 1179 return IRQ_RETVAL(handled); 1180 } 1181 1182 static void pvscsi_free_sgls(const struct pvscsi_adapter *adapter) 1183 { 1184 struct pvscsi_ctx *ctx = adapter->cmd_map; 1185 unsigned i; 1186 1187 for (i = 0; i < adapter->req_depth; ++i, ++ctx) 1188 free_pages((unsigned long)ctx->sgl, get_order(SGL_SIZE)); 1189 } 1190 1191 static int pvscsi_setup_msix(const struct pvscsi_adapter *adapter, 1192 unsigned int *irq) 1193 { 1194 struct msix_entry entry = { 0, PVSCSI_VECTOR_COMPLETION }; 1195 int ret; 1196 1197 ret = pci_enable_msix_exact(adapter->dev, &entry, 1); 1198 if (ret) 1199 return ret; 1200 1201 *irq = entry.vector; 1202 1203 return 0; 1204 } 1205 1206 static void pvscsi_shutdown_intr(struct pvscsi_adapter *adapter) 1207 { 1208 if (adapter->irq) { 1209 free_irq(adapter->irq, adapter); 1210 adapter->irq = 0; 1211 } 1212 if (adapter->use_msi) { 1213 pci_disable_msi(adapter->dev); 1214 adapter->use_msi = 0; 1215 } else if (adapter->use_msix) { 1216 pci_disable_msix(adapter->dev); 1217 adapter->use_msix = 0; 1218 } 1219 } 1220 1221 static void pvscsi_release_resources(struct pvscsi_adapter *adapter) 1222 { 1223 pvscsi_shutdown_intr(adapter); 1224 1225 if (adapter->workqueue) 1226 destroy_workqueue(adapter->workqueue); 1227 1228 if (adapter->mmioBase) 1229 pci_iounmap(adapter->dev, adapter->mmioBase); 1230 1231 pci_release_regions(adapter->dev); 1232 1233 if (adapter->cmd_map) { 1234 pvscsi_free_sgls(adapter); 1235 kfree(adapter->cmd_map); 1236 } 1237 1238 if (adapter->rings_state) 1239 pci_free_consistent(adapter->dev, PAGE_SIZE, 1240 adapter->rings_state, adapter->ringStatePA); 1241 1242 if (adapter->req_ring) 1243 pci_free_consistent(adapter->dev, 1244 adapter->req_pages * PAGE_SIZE, 1245 adapter->req_ring, adapter->reqRingPA); 1246 1247 if (adapter->cmp_ring) 1248 pci_free_consistent(adapter->dev, 1249 adapter->cmp_pages * PAGE_SIZE, 1250 adapter->cmp_ring, adapter->cmpRingPA); 1251 1252 if (adapter->msg_ring) 1253 pci_free_consistent(adapter->dev, 1254 adapter->msg_pages * PAGE_SIZE, 1255 adapter->msg_ring, adapter->msgRingPA); 1256 } 1257 1258 /* 1259 * Allocate scatter gather lists. 1260 * 1261 * These are statically allocated. Trying to be clever was not worth it. 1262 * 1263 * Dynamic allocation can fail, and we can't go deep into the memory 1264 * allocator, since we're a SCSI driver, and trying too hard to allocate 1265 * memory might generate disk I/O. We also don't want to fail disk I/O 1266 * in that case because we can't get an allocation - the I/O could be 1267 * trying to swap out data to free memory. Since that is pathological, 1268 * just use a statically allocated scatter list. 1269 * 1270 */ 1271 static int pvscsi_allocate_sg(struct pvscsi_adapter *adapter) 1272 { 1273 struct pvscsi_ctx *ctx; 1274 int i; 1275 1276 ctx = adapter->cmd_map; 1277 BUILD_BUG_ON(sizeof(struct pvscsi_sg_list) > SGL_SIZE); 1278 1279 for (i = 0; i < adapter->req_depth; ++i, ++ctx) { 1280 ctx->sgl = (void *)__get_free_pages(GFP_KERNEL, 1281 get_order(SGL_SIZE)); 1282 ctx->sglPA = 0; 1283 BUG_ON(!IS_ALIGNED(((unsigned long)ctx->sgl), PAGE_SIZE)); 1284 if (!ctx->sgl) { 1285 for (; i >= 0; --i, --ctx) { 1286 free_pages((unsigned long)ctx->sgl, 1287 get_order(SGL_SIZE)); 1288 ctx->sgl = NULL; 1289 } 1290 return -ENOMEM; 1291 } 1292 } 1293 1294 return 0; 1295 } 1296 1297 /* 1298 * Query the device, fetch the config info and return the 1299 * maximum number of targets on the adapter. In case of 1300 * failure due to any reason return default i.e. 16. 1301 */ 1302 static u32 pvscsi_get_max_targets(struct pvscsi_adapter *adapter) 1303 { 1304 struct PVSCSICmdDescConfigCmd cmd; 1305 struct PVSCSIConfigPageHeader *header; 1306 struct device *dev; 1307 dma_addr_t configPagePA; 1308 void *config_page; 1309 u32 numPhys = 16; 1310 1311 dev = pvscsi_dev(adapter); 1312 config_page = pci_alloc_consistent(adapter->dev, PAGE_SIZE, 1313 &configPagePA); 1314 if (!config_page) { 1315 dev_warn(dev, "vmw_pvscsi: failed to allocate memory for config page\n"); 1316 goto exit; 1317 } 1318 BUG_ON(configPagePA & ~PAGE_MASK); 1319 1320 /* Fetch config info from the device. */ 1321 cmd.configPageAddress = ((u64)PVSCSI_CONFIG_CONTROLLER_ADDRESS) << 32; 1322 cmd.configPageNum = PVSCSI_CONFIG_PAGE_CONTROLLER; 1323 cmd.cmpAddr = configPagePA; 1324 cmd._pad = 0; 1325 1326 /* 1327 * Mark the completion page header with error values. If the device 1328 * completes the command successfully, it sets the status values to 1329 * indicate success. 1330 */ 1331 header = config_page; 1332 memset(header, 0, sizeof *header); 1333 header->hostStatus = BTSTAT_INVPARAM; 1334 header->scsiStatus = SDSTAT_CHECK; 1335 1336 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_CONFIG, &cmd, sizeof cmd); 1337 1338 if (header->hostStatus == BTSTAT_SUCCESS && 1339 header->scsiStatus == SDSTAT_GOOD) { 1340 struct PVSCSIConfigPageController *config; 1341 1342 config = config_page; 1343 numPhys = config->numPhys; 1344 } else 1345 dev_warn(dev, "vmw_pvscsi: PVSCSI_CMD_CONFIG failed. hostStatus = 0x%x, scsiStatus = 0x%x\n", 1346 header->hostStatus, header->scsiStatus); 1347 pci_free_consistent(adapter->dev, PAGE_SIZE, config_page, configPagePA); 1348 exit: 1349 return numPhys; 1350 } 1351 1352 static int pvscsi_probe(struct pci_dev *pdev, const struct pci_device_id *id) 1353 { 1354 struct pvscsi_adapter *adapter; 1355 struct pvscsi_adapter adapter_temp; 1356 struct Scsi_Host *host = NULL; 1357 unsigned int i; 1358 unsigned long flags = 0; 1359 int error; 1360 u32 max_id; 1361 1362 error = -ENODEV; 1363 1364 if (pci_enable_device(pdev)) 1365 return error; 1366 1367 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) == 0 && 1368 pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)) == 0) { 1369 printk(KERN_INFO "vmw_pvscsi: using 64bit dma\n"); 1370 } else if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) == 0 && 1371 pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)) == 0) { 1372 printk(KERN_INFO "vmw_pvscsi: using 32bit dma\n"); 1373 } else { 1374 printk(KERN_ERR "vmw_pvscsi: failed to set DMA mask\n"); 1375 goto out_disable_device; 1376 } 1377 1378 /* 1379 * Let's use a temp pvscsi_adapter struct until we find the number of 1380 * targets on the adapter, after that we will switch to the real 1381 * allocated struct. 1382 */ 1383 adapter = &adapter_temp; 1384 memset(adapter, 0, sizeof(*adapter)); 1385 adapter->dev = pdev; 1386 adapter->rev = pdev->revision; 1387 1388 if (pci_request_regions(pdev, "vmw_pvscsi")) { 1389 printk(KERN_ERR "vmw_pvscsi: pci memory selection failed\n"); 1390 goto out_disable_device; 1391 } 1392 1393 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) { 1394 if ((pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE_IO)) 1395 continue; 1396 1397 if (pci_resource_len(pdev, i) < PVSCSI_MEM_SPACE_SIZE) 1398 continue; 1399 1400 break; 1401 } 1402 1403 if (i == DEVICE_COUNT_RESOURCE) { 1404 printk(KERN_ERR 1405 "vmw_pvscsi: adapter has no suitable MMIO region\n"); 1406 goto out_release_resources_and_disable; 1407 } 1408 1409 adapter->mmioBase = pci_iomap(pdev, i, PVSCSI_MEM_SPACE_SIZE); 1410 1411 if (!adapter->mmioBase) { 1412 printk(KERN_ERR 1413 "vmw_pvscsi: can't iomap for BAR %d memsize %lu\n", 1414 i, PVSCSI_MEM_SPACE_SIZE); 1415 goto out_release_resources_and_disable; 1416 } 1417 1418 pci_set_master(pdev); 1419 1420 /* 1421 * Ask the device for max number of targets before deciding the 1422 * default pvscsi_ring_pages value. 1423 */ 1424 max_id = pvscsi_get_max_targets(adapter); 1425 printk(KERN_INFO "vmw_pvscsi: max_id: %u\n", max_id); 1426 1427 if (pvscsi_ring_pages == 0) 1428 /* 1429 * Set the right default value. Up to 16 it is 8, above it is 1430 * max. 1431 */ 1432 pvscsi_ring_pages = (max_id > 16) ? 1433 PVSCSI_SETUP_RINGS_MAX_NUM_PAGES : 1434 PVSCSI_DEFAULT_NUM_PAGES_PER_RING; 1435 printk(KERN_INFO 1436 "vmw_pvscsi: setting ring_pages to %d\n", 1437 pvscsi_ring_pages); 1438 1439 pvscsi_template.can_queue = 1440 min(PVSCSI_MAX_NUM_PAGES_REQ_RING, pvscsi_ring_pages) * 1441 PVSCSI_MAX_NUM_REQ_ENTRIES_PER_PAGE; 1442 pvscsi_template.cmd_per_lun = 1443 min(pvscsi_template.can_queue, pvscsi_cmd_per_lun); 1444 host = scsi_host_alloc(&pvscsi_template, sizeof(struct pvscsi_adapter)); 1445 if (!host) { 1446 printk(KERN_ERR "vmw_pvscsi: failed to allocate host\n"); 1447 goto out_release_resources_and_disable; 1448 } 1449 1450 /* 1451 * Let's use the real pvscsi_adapter struct here onwards. 1452 */ 1453 adapter = shost_priv(host); 1454 memset(adapter, 0, sizeof(*adapter)); 1455 adapter->dev = pdev; 1456 adapter->host = host; 1457 /* 1458 * Copy back what we already have to the allocated adapter struct. 1459 */ 1460 adapter->rev = adapter_temp.rev; 1461 adapter->mmioBase = adapter_temp.mmioBase; 1462 1463 spin_lock_init(&adapter->hw_lock); 1464 host->max_channel = 0; 1465 host->max_lun = 1; 1466 host->max_cmd_len = 16; 1467 host->max_id = max_id; 1468 1469 pci_set_drvdata(pdev, host); 1470 1471 ll_adapter_reset(adapter); 1472 1473 adapter->use_msg = pvscsi_setup_msg_workqueue(adapter); 1474 1475 error = pvscsi_allocate_rings(adapter); 1476 if (error) { 1477 printk(KERN_ERR "vmw_pvscsi: unable to allocate ring memory\n"); 1478 goto out_release_resources; 1479 } 1480 1481 /* 1482 * From this point on we should reset the adapter if anything goes 1483 * wrong. 1484 */ 1485 pvscsi_setup_all_rings(adapter); 1486 1487 adapter->cmd_map = kcalloc(adapter->req_depth, 1488 sizeof(struct pvscsi_ctx), GFP_KERNEL); 1489 if (!adapter->cmd_map) { 1490 printk(KERN_ERR "vmw_pvscsi: failed to allocate memory.\n"); 1491 error = -ENOMEM; 1492 goto out_reset_adapter; 1493 } 1494 1495 INIT_LIST_HEAD(&adapter->cmd_pool); 1496 for (i = 0; i < adapter->req_depth; i++) { 1497 struct pvscsi_ctx *ctx = adapter->cmd_map + i; 1498 list_add(&ctx->list, &adapter->cmd_pool); 1499 } 1500 1501 error = pvscsi_allocate_sg(adapter); 1502 if (error) { 1503 printk(KERN_ERR "vmw_pvscsi: unable to allocate s/g table\n"); 1504 goto out_reset_adapter; 1505 } 1506 1507 if (!pvscsi_disable_msix && 1508 pvscsi_setup_msix(adapter, &adapter->irq) == 0) { 1509 printk(KERN_INFO "vmw_pvscsi: using MSI-X\n"); 1510 adapter->use_msix = 1; 1511 } else if (!pvscsi_disable_msi && pci_enable_msi(pdev) == 0) { 1512 printk(KERN_INFO "vmw_pvscsi: using MSI\n"); 1513 adapter->use_msi = 1; 1514 adapter->irq = pdev->irq; 1515 } else { 1516 printk(KERN_INFO "vmw_pvscsi: using INTx\n"); 1517 adapter->irq = pdev->irq; 1518 flags = IRQF_SHARED; 1519 } 1520 1521 adapter->use_req_threshold = pvscsi_setup_req_threshold(adapter, true); 1522 printk(KERN_DEBUG "vmw_pvscsi: driver-based request coalescing %sabled\n", 1523 adapter->use_req_threshold ? "en" : "dis"); 1524 1525 error = request_irq(adapter->irq, pvscsi_isr, flags, 1526 "vmw_pvscsi", adapter); 1527 if (error) { 1528 printk(KERN_ERR 1529 "vmw_pvscsi: unable to request IRQ: %d\n", error); 1530 adapter->irq = 0; 1531 goto out_reset_adapter; 1532 } 1533 1534 error = scsi_add_host(host, &pdev->dev); 1535 if (error) { 1536 printk(KERN_ERR 1537 "vmw_pvscsi: scsi_add_host failed: %d\n", error); 1538 goto out_reset_adapter; 1539 } 1540 1541 dev_info(&pdev->dev, "VMware PVSCSI rev %d host #%u\n", 1542 adapter->rev, host->host_no); 1543 1544 pvscsi_unmask_intr(adapter); 1545 1546 scsi_scan_host(host); 1547 1548 return 0; 1549 1550 out_reset_adapter: 1551 ll_adapter_reset(adapter); 1552 out_release_resources: 1553 pvscsi_release_resources(adapter); 1554 scsi_host_put(host); 1555 out_disable_device: 1556 pci_disable_device(pdev); 1557 1558 return error; 1559 1560 out_release_resources_and_disable: 1561 pvscsi_release_resources(adapter); 1562 goto out_disable_device; 1563 } 1564 1565 static void __pvscsi_shutdown(struct pvscsi_adapter *adapter) 1566 { 1567 pvscsi_mask_intr(adapter); 1568 1569 if (adapter->workqueue) 1570 flush_workqueue(adapter->workqueue); 1571 1572 pvscsi_shutdown_intr(adapter); 1573 1574 pvscsi_process_request_ring(adapter); 1575 pvscsi_process_completion_ring(adapter); 1576 ll_adapter_reset(adapter); 1577 } 1578 1579 static void pvscsi_shutdown(struct pci_dev *dev) 1580 { 1581 struct Scsi_Host *host = pci_get_drvdata(dev); 1582 struct pvscsi_adapter *adapter = shost_priv(host); 1583 1584 __pvscsi_shutdown(adapter); 1585 } 1586 1587 static void pvscsi_remove(struct pci_dev *pdev) 1588 { 1589 struct Scsi_Host *host = pci_get_drvdata(pdev); 1590 struct pvscsi_adapter *adapter = shost_priv(host); 1591 1592 scsi_remove_host(host); 1593 1594 __pvscsi_shutdown(adapter); 1595 pvscsi_release_resources(adapter); 1596 1597 scsi_host_put(host); 1598 1599 pci_disable_device(pdev); 1600 } 1601 1602 static struct pci_driver pvscsi_pci_driver = { 1603 .name = "vmw_pvscsi", 1604 .id_table = pvscsi_pci_tbl, 1605 .probe = pvscsi_probe, 1606 .remove = pvscsi_remove, 1607 .shutdown = pvscsi_shutdown, 1608 }; 1609 1610 static int __init pvscsi_init(void) 1611 { 1612 pr_info("%s - version %s\n", 1613 PVSCSI_LINUX_DRIVER_DESC, PVSCSI_DRIVER_VERSION_STRING); 1614 return pci_register_driver(&pvscsi_pci_driver); 1615 } 1616 1617 static void __exit pvscsi_exit(void) 1618 { 1619 pci_unregister_driver(&pvscsi_pci_driver); 1620 } 1621 1622 module_init(pvscsi_init); 1623 module_exit(pvscsi_exit); 1624