2 * Linux driver for VMware's para-virtualized SCSI HBA.
4 * Copyright (C) 2008-2014, VMware, Inc. All Rights Reserved.
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.
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
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.
20 * Maintained by: Jim Gill <jgill@vmware.com>
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>
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>
37 #include "vmw_pvscsi.h"
39 #define PVSCSI_LINUX_DRIVER_DESC "VMware PVSCSI driver"
41 MODULE_DESCRIPTION(PVSCSI_LINUX_DRIVER_DESC
);
42 MODULE_AUTHOR("VMware, Inc.");
43 MODULE_LICENSE("GPL");
44 MODULE_VERSION(PVSCSI_DRIVER_VERSION_STRING
);
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
51 struct pvscsi_sg_list
{
52 struct PVSCSISGElement sge
[PVSCSI_MAX_NUM_SG_ENTRIES_PER_SEGMENT
];
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.
60 struct scsi_cmnd
*cmd
;
61 struct pvscsi_sg_list
*sgl
;
62 struct list_head list
;
66 struct completion
*abort_cmp
;
69 struct pvscsi_adapter
{
76 bool use_req_threshold
;
80 struct workqueue_struct
*workqueue
;
81 struct work_struct work
;
83 struct PVSCSIRingReqDesc
*req_ring
;
88 struct PVSCSIRingCmpDesc
*cmp_ring
;
92 struct PVSCSIRingMsgDesc
*msg_ring
;
96 struct PVSCSIRingsState
*rings_state
;
97 dma_addr_t ringStatePA
;
100 struct Scsi_Host
*host
;
102 struct list_head cmd_pool
;
103 struct pvscsi_ctx
*cmd_map
;
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;
116 #define PVSCSI_RW (S_IRUSR | S_IWUSR)
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])");
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
) ")");
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
) ")");
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)");
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)");
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)");
142 module_param_named(use_req_threshold
, pvscsi_use_req_threshold
,
144 MODULE_PARM_DESC(use_req_threshold
, "Use driver-based request coalescing if configured - (default=1)");
146 static const struct pci_device_id pvscsi_pci_tbl
[] = {
147 { PCI_VDEVICE(VMWARE
, PCI_DEVICE_ID_VMWARE_PVSCSI
) },
151 MODULE_DEVICE_TABLE(pci
, pvscsi_pci_tbl
);
153 static struct device
*
154 pvscsi_dev(const struct pvscsi_adapter
*adapter
)
156 return &(adapter
->dev
->dev
);
159 static struct pvscsi_ctx
*
160 pvscsi_find_context(const struct pvscsi_adapter
*adapter
, struct scsi_cmnd
*cmd
)
162 struct pvscsi_ctx
*ctx
, *end
;
164 end
= &adapter
->cmd_map
[adapter
->req_depth
];
165 for (ctx
= adapter
->cmd_map
; ctx
< end
; ctx
++)
172 static struct pvscsi_ctx
*
173 pvscsi_acquire_context(struct pvscsi_adapter
*adapter
, struct scsi_cmnd
*cmd
)
175 struct pvscsi_ctx
*ctx
;
177 if (list_empty(&adapter
->cmd_pool
))
180 ctx
= list_first_entry(&adapter
->cmd_pool
, struct pvscsi_ctx
, list
);
182 list_del(&ctx
->list
);
187 static void pvscsi_release_context(struct pvscsi_adapter
*adapter
,
188 struct pvscsi_ctx
*ctx
)
191 ctx
->abort_cmp
= NULL
;
192 list_add(&ctx
->list
, &adapter
->cmd_pool
);
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.
200 static u64
pvscsi_map_context(const struct pvscsi_adapter
*adapter
,
201 const struct pvscsi_ctx
*ctx
)
203 return ctx
- adapter
->cmd_map
+ 1;
206 static struct pvscsi_ctx
*
207 pvscsi_get_context(const struct pvscsi_adapter
*adapter
, u64 context
)
209 return &adapter
->cmd_map
[context
- 1];
212 static void pvscsi_reg_write(const struct pvscsi_adapter
*adapter
,
215 writel(val
, adapter
->mmioBase
+ offset
);
218 static u32
pvscsi_reg_read(const struct pvscsi_adapter
*adapter
, u32 offset
)
220 return readl(adapter
->mmioBase
+ offset
);
223 static u32
pvscsi_read_intr_status(const struct pvscsi_adapter
*adapter
)
225 return pvscsi_reg_read(adapter
, PVSCSI_REG_OFFSET_INTR_STATUS
);
228 static void pvscsi_write_intr_status(const struct pvscsi_adapter
*adapter
,
231 pvscsi_reg_write(adapter
, PVSCSI_REG_OFFSET_INTR_STATUS
, val
);
234 static void pvscsi_unmask_intr(const struct pvscsi_adapter
*adapter
)
238 intr_bits
= PVSCSI_INTR_CMPL_MASK
;
239 if (adapter
->use_msg
)
240 intr_bits
|= PVSCSI_INTR_MSG_MASK
;
242 pvscsi_reg_write(adapter
, PVSCSI_REG_OFFSET_INTR_MASK
, intr_bits
);
245 static void pvscsi_mask_intr(const struct pvscsi_adapter
*adapter
)
247 pvscsi_reg_write(adapter
, PVSCSI_REG_OFFSET_INTR_MASK
, 0);
250 static void pvscsi_write_cmd_desc(const struct pvscsi_adapter
*adapter
,
251 u32 cmd
, const void *desc
, size_t len
)
253 const u32
*ptr
= desc
;
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
]);
263 static void pvscsi_abort_cmd(const struct pvscsi_adapter
*adapter
,
264 const struct pvscsi_ctx
*ctx
)
266 struct PVSCSICmdDescAbortCmd cmd
= { 0 };
268 cmd
.target
= ctx
->cmd
->device
->id
;
269 cmd
.context
= pvscsi_map_context(adapter
, ctx
);
271 pvscsi_write_cmd_desc(adapter
, PVSCSI_CMD_ABORT_CMD
, &cmd
, sizeof(cmd
));
274 static void pvscsi_kick_rw_io(const struct pvscsi_adapter
*adapter
)
276 pvscsi_reg_write(adapter
, PVSCSI_REG_OFFSET_KICK_RW_IO
, 0);
279 static void pvscsi_process_request_ring(const struct pvscsi_adapter
*adapter
)
281 pvscsi_reg_write(adapter
, PVSCSI_REG_OFFSET_KICK_NON_RW_IO
, 0);
284 static int scsi_is_rw(unsigned char op
)
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
;
292 static void pvscsi_kick_io(const struct pvscsi_adapter
*adapter
,
295 if (scsi_is_rw(op
)) {
296 struct PVSCSIRingsState
*s
= adapter
->rings_state
;
298 if (!adapter
->use_req_threshold
||
299 s
->reqProdIdx
- s
->reqConsIdx
>= s
->reqCallThreshold
)
300 pvscsi_kick_rw_io(adapter
);
302 pvscsi_process_request_ring(adapter
);
306 static void ll_adapter_reset(const struct pvscsi_adapter
*adapter
)
308 dev_dbg(pvscsi_dev(adapter
), "Adapter Reset on %p\n", adapter
);
310 pvscsi_write_cmd_desc(adapter
, PVSCSI_CMD_ADAPTER_RESET
, NULL
, 0);
313 static void ll_bus_reset(const struct pvscsi_adapter
*adapter
)
315 dev_dbg(pvscsi_dev(adapter
), "Resetting bus on %p\n", adapter
);
317 pvscsi_write_cmd_desc(adapter
, PVSCSI_CMD_RESET_BUS
, NULL
, 0);
320 static void ll_device_reset(const struct pvscsi_adapter
*adapter
, u32 target
)
322 struct PVSCSICmdDescResetDevice cmd
= { 0 };
324 dev_dbg(pvscsi_dev(adapter
), "Resetting device: target=%u\n", target
);
328 pvscsi_write_cmd_desc(adapter
, PVSCSI_CMD_RESET_DEVICE
,
332 static void pvscsi_create_sg(struct pvscsi_ctx
*ctx
,
333 struct scatterlist
*sg
, unsigned count
)
336 struct PVSCSISGElement
*sge
;
338 BUG_ON(count
> PVSCSI_MAX_NUM_SG_ENTRIES_PER_SEGMENT
);
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
);
349 * Map all data buffers for a command into PCI space and
350 * setup the scatter/gather list if needed.
352 static int pvscsi_map_buffers(struct pvscsi_adapter
*adapter
,
353 struct pvscsi_ctx
*ctx
, struct scsi_cmnd
*cmd
,
354 struct PVSCSIRingReqDesc
*e
)
357 unsigned bufflen
= scsi_bufflen(cmd
);
358 struct scatterlist
*sg
;
360 e
->dataLen
= bufflen
;
365 sg
= scsi_sglist(cmd
);
366 count
= scsi_sg_count(cmd
);
368 int segs
= scsi_dma_map(cmd
);
370 if (segs
== -ENOMEM
) {
371 scmd_printk(KERN_ERR
, cmd
,
372 "vmw_pvscsi: Failed to map cmd sglist for DMA.\n");
374 } else if (segs
> 1) {
375 pvscsi_create_sg(ctx
, sg
, segs
);
377 e
->flags
|= PVSCSI_FLAG_CMD_WITH_SG_LIST
;
378 ctx
->sglPA
= pci_map_single(adapter
->dev
, ctx
->sgl
,
379 SGL_SIZE
, PCI_DMA_TODEVICE
);
380 if (pci_dma_mapping_error(adapter
->dev
, ctx
->sglPA
)) {
381 scmd_printk(KERN_ERR
, cmd
,
382 "vmw_pvscsi: Failed to map ctx sglist for DMA.\n");
387 e
->dataAddr
= ctx
->sglPA
;
389 e
->dataAddr
= sg_dma_address(sg
);
392 * In case there is no S/G list, scsi_sglist points
393 * directly to the buffer.
395 ctx
->dataPA
= pci_map_single(adapter
->dev
, sg
, bufflen
,
396 cmd
->sc_data_direction
);
397 if (pci_dma_mapping_error(adapter
->dev
, ctx
->dataPA
)) {
398 scmd_printk(KERN_ERR
, cmd
,
399 "vmw_pvscsi: Failed to map direct data buffer for DMA.\n");
402 e
->dataAddr
= ctx
->dataPA
;
408 static void pvscsi_unmap_buffers(const struct pvscsi_adapter
*adapter
,
409 struct pvscsi_ctx
*ctx
)
411 struct scsi_cmnd
*cmd
;
415 bufflen
= scsi_bufflen(cmd
);
418 unsigned count
= scsi_sg_count(cmd
);
423 pci_unmap_single(adapter
->dev
, ctx
->sglPA
,
424 SGL_SIZE
, PCI_DMA_TODEVICE
);
428 pci_unmap_single(adapter
->dev
, ctx
->dataPA
, bufflen
,
429 cmd
->sc_data_direction
);
431 if (cmd
->sense_buffer
)
432 pci_unmap_single(adapter
->dev
, ctx
->sensePA
,
433 SCSI_SENSE_BUFFERSIZE
, PCI_DMA_FROMDEVICE
);
436 static int pvscsi_allocate_rings(struct pvscsi_adapter
*adapter
)
438 adapter
->rings_state
= pci_alloc_consistent(adapter
->dev
, PAGE_SIZE
,
439 &adapter
->ringStatePA
);
440 if (!adapter
->rings_state
)
443 adapter
->req_pages
= min(PVSCSI_MAX_NUM_PAGES_REQ_RING
,
445 adapter
->req_depth
= adapter
->req_pages
446 * PVSCSI_MAX_NUM_REQ_ENTRIES_PER_PAGE
;
447 adapter
->req_ring
= pci_alloc_consistent(adapter
->dev
,
448 adapter
->req_pages
* PAGE_SIZE
,
449 &adapter
->reqRingPA
);
450 if (!adapter
->req_ring
)
453 adapter
->cmp_pages
= min(PVSCSI_MAX_NUM_PAGES_CMP_RING
,
455 adapter
->cmp_ring
= pci_alloc_consistent(adapter
->dev
,
456 adapter
->cmp_pages
* PAGE_SIZE
,
457 &adapter
->cmpRingPA
);
458 if (!adapter
->cmp_ring
)
461 BUG_ON(!IS_ALIGNED(adapter
->ringStatePA
, PAGE_SIZE
));
462 BUG_ON(!IS_ALIGNED(adapter
->reqRingPA
, PAGE_SIZE
));
463 BUG_ON(!IS_ALIGNED(adapter
->cmpRingPA
, PAGE_SIZE
));
465 if (!adapter
->use_msg
)
468 adapter
->msg_pages
= min(PVSCSI_MAX_NUM_PAGES_MSG_RING
,
469 pvscsi_msg_ring_pages
);
470 adapter
->msg_ring
= pci_alloc_consistent(adapter
->dev
,
471 adapter
->msg_pages
* PAGE_SIZE
,
472 &adapter
->msgRingPA
);
473 if (!adapter
->msg_ring
)
475 BUG_ON(!IS_ALIGNED(adapter
->msgRingPA
, PAGE_SIZE
));
480 static void pvscsi_setup_all_rings(const struct pvscsi_adapter
*adapter
)
482 struct PVSCSICmdDescSetupRings cmd
= { 0 };
486 cmd
.ringsStatePPN
= adapter
->ringStatePA
>> PAGE_SHIFT
;
487 cmd
.reqRingNumPages
= adapter
->req_pages
;
488 cmd
.cmpRingNumPages
= adapter
->cmp_pages
;
490 base
= adapter
->reqRingPA
;
491 for (i
= 0; i
< adapter
->req_pages
; i
++) {
492 cmd
.reqRingPPNs
[i
] = base
>> PAGE_SHIFT
;
496 base
= adapter
->cmpRingPA
;
497 for (i
= 0; i
< adapter
->cmp_pages
; i
++) {
498 cmd
.cmpRingPPNs
[i
] = base
>> PAGE_SHIFT
;
502 memset(adapter
->rings_state
, 0, PAGE_SIZE
);
503 memset(adapter
->req_ring
, 0, adapter
->req_pages
* PAGE_SIZE
);
504 memset(adapter
->cmp_ring
, 0, adapter
->cmp_pages
* PAGE_SIZE
);
506 pvscsi_write_cmd_desc(adapter
, PVSCSI_CMD_SETUP_RINGS
,
509 if (adapter
->use_msg
) {
510 struct PVSCSICmdDescSetupMsgRing cmd_msg
= { 0 };
512 cmd_msg
.numPages
= adapter
->msg_pages
;
514 base
= adapter
->msgRingPA
;
515 for (i
= 0; i
< adapter
->msg_pages
; i
++) {
516 cmd_msg
.ringPPNs
[i
] = base
>> PAGE_SHIFT
;
519 memset(adapter
->msg_ring
, 0, adapter
->msg_pages
* PAGE_SIZE
);
521 pvscsi_write_cmd_desc(adapter
, PVSCSI_CMD_SETUP_MSG_RING
,
522 &cmd_msg
, sizeof(cmd_msg
));
526 static int pvscsi_change_queue_depth(struct scsi_device
*sdev
, int qdepth
)
528 if (!sdev
->tagged_supported
)
530 return scsi_change_queue_depth(sdev
, qdepth
);
534 * Pull a completion descriptor off and pass the completion back
535 * to the SCSI mid layer.
537 static void pvscsi_complete_request(struct pvscsi_adapter
*adapter
,
538 const struct PVSCSIRingCmpDesc
*e
)
540 struct pvscsi_ctx
*ctx
;
541 struct scsi_cmnd
*cmd
;
542 struct completion
*abort_cmp
;
543 u32 btstat
= e
->hostStatus
;
544 u32 sdstat
= e
->scsiStatus
;
546 ctx
= pvscsi_get_context(adapter
, e
->context
);
548 abort_cmp
= ctx
->abort_cmp
;
549 pvscsi_unmap_buffers(adapter
, ctx
);
550 pvscsi_release_context(adapter
, ctx
);
553 * The command was requested to be aborted. Just signal that
554 * the request completed and swallow the actual cmd completion
555 * here. The abort handler will post a completion for this
556 * command indicating that it got successfully aborted.
563 if (sdstat
!= SAM_STAT_GOOD
&&
564 (btstat
== BTSTAT_SUCCESS
||
565 btstat
== BTSTAT_LINKED_COMMAND_COMPLETED
||
566 btstat
== BTSTAT_LINKED_COMMAND_COMPLETED_WITH_FLAG
)) {
567 cmd
->result
= (DID_OK
<< 16) | sdstat
;
568 if (sdstat
== SAM_STAT_CHECK_CONDITION
&& cmd
->sense_buffer
)
569 cmd
->result
|= (DRIVER_SENSE
<< 24);
573 case BTSTAT_LINKED_COMMAND_COMPLETED
:
574 case BTSTAT_LINKED_COMMAND_COMPLETED_WITH_FLAG
:
575 /* If everything went fine, let's move on.. */
576 cmd
->result
= (DID_OK
<< 16);
580 case BTSTAT_DATA_UNDERRUN
:
581 /* Report residual data in underruns */
582 scsi_set_resid(cmd
, scsi_bufflen(cmd
) - e
->dataLen
);
583 cmd
->result
= (DID_ERROR
<< 16);
586 case BTSTAT_SELTIMEO
:
587 /* Our emulation returns this for non-connected devs */
588 cmd
->result
= (DID_BAD_TARGET
<< 16);
591 case BTSTAT_LUNMISMATCH
:
592 case BTSTAT_TAGREJECT
:
594 cmd
->result
= (DRIVER_INVALID
<< 24);
597 case BTSTAT_HAHARDWARE
:
598 case BTSTAT_INVPHASE
:
599 case BTSTAT_HATIMEOUT
:
600 case BTSTAT_NORESPONSE
:
601 case BTSTAT_DISCONNECT
:
602 case BTSTAT_HASOFTWARE
:
604 case BTSTAT_SENSFAILED
:
605 cmd
->result
|= (DID_ERROR
<< 16);
610 case BTSTAT_BUSRESET
:
611 cmd
->result
= (DID_RESET
<< 16);
614 case BTSTAT_ABORTQUEUE
:
615 cmd
->result
= (DID_ABORT
<< 16);
618 case BTSTAT_SCSIPARITY
:
619 cmd
->result
= (DID_PARITY
<< 16);
623 cmd
->result
= (DID_ERROR
<< 16);
624 scmd_printk(KERN_DEBUG
, cmd
,
625 "Unknown completion status: 0x%x\n",
629 dev_dbg(&cmd
->device
->sdev_gendev
,
630 "cmd=%p %x ctx=%p result=0x%x status=0x%x,%x\n",
631 cmd
, cmd
->cmnd
[0], ctx
, cmd
->result
, btstat
, sdstat
);
637 * barrier usage : Since the PVSCSI device is emulated, there could be cases
638 * where we may want to serialize some accesses between the driver and the
639 * emulation layer. We use compiler barriers instead of the more expensive
640 * memory barriers because PVSCSI is only supported on X86 which has strong
641 * memory access ordering.
643 static void pvscsi_process_completion_ring(struct pvscsi_adapter
*adapter
)
645 struct PVSCSIRingsState
*s
= adapter
->rings_state
;
646 struct PVSCSIRingCmpDesc
*ring
= adapter
->cmp_ring
;
647 u32 cmp_entries
= s
->cmpNumEntriesLog2
;
649 while (s
->cmpConsIdx
!= s
->cmpProdIdx
) {
650 struct PVSCSIRingCmpDesc
*e
= ring
+ (s
->cmpConsIdx
&
653 * This barrier() ensures that *e is not dereferenced while
654 * the device emulation still writes data into the slot.
655 * Since the device emulation advances s->cmpProdIdx only after
656 * updating the slot we want to check it first.
659 pvscsi_complete_request(adapter
, e
);
661 * This barrier() ensures that compiler doesn't reorder write
662 * to s->cmpConsIdx before the read of (*e) inside
663 * pvscsi_complete_request. Otherwise, device emulation may
664 * overwrite *e before we had a chance to read it.
672 * Translate a Linux SCSI request into a request ring entry.
674 static int pvscsi_queue_ring(struct pvscsi_adapter
*adapter
,
675 struct pvscsi_ctx
*ctx
, struct scsi_cmnd
*cmd
)
677 struct PVSCSIRingsState
*s
;
678 struct PVSCSIRingReqDesc
*e
;
679 struct scsi_device
*sdev
;
682 s
= adapter
->rings_state
;
684 req_entries
= s
->reqNumEntriesLog2
;
687 * If this condition holds, we might have room on the request ring, but
688 * we might not have room on the completion ring for the response.
689 * However, we have already ruled out this possibility - we would not
690 * have successfully allocated a context if it were true, since we only
691 * have one context per request entry. Check for it anyway, since it
692 * would be a serious bug.
694 if (s
->reqProdIdx
- s
->cmpConsIdx
>= 1 << req_entries
) {
695 scmd_printk(KERN_ERR
, cmd
, "vmw_pvscsi: "
696 "ring full: reqProdIdx=%d cmpConsIdx=%d\n",
697 s
->reqProdIdx
, s
->cmpConsIdx
);
701 e
= adapter
->req_ring
+ (s
->reqProdIdx
& MASK(req_entries
));
703 e
->bus
= sdev
->channel
;
704 e
->target
= sdev
->id
;
705 memset(e
->lun
, 0, sizeof(e
->lun
));
706 e
->lun
[1] = sdev
->lun
;
708 if (cmd
->sense_buffer
) {
709 ctx
->sensePA
= pci_map_single(adapter
->dev
, cmd
->sense_buffer
,
710 SCSI_SENSE_BUFFERSIZE
,
712 if (pci_dma_mapping_error(adapter
->dev
, ctx
->sensePA
)) {
713 scmd_printk(KERN_ERR
, cmd
,
714 "vmw_pvscsi: Failed to map sense buffer for DMA.\n");
718 e
->senseAddr
= ctx
->sensePA
;
719 e
->senseLen
= SCSI_SENSE_BUFFERSIZE
;
724 e
->cdbLen
= cmd
->cmd_len
;
725 e
->vcpuHint
= smp_processor_id();
726 memcpy(e
->cdb
, cmd
->cmnd
, e
->cdbLen
);
728 e
->tag
= SIMPLE_QUEUE_TAG
;
730 if (cmd
->sc_data_direction
== DMA_FROM_DEVICE
)
731 e
->flags
= PVSCSI_FLAG_CMD_DIR_TOHOST
;
732 else if (cmd
->sc_data_direction
== DMA_TO_DEVICE
)
733 e
->flags
= PVSCSI_FLAG_CMD_DIR_TODEVICE
;
734 else if (cmd
->sc_data_direction
== DMA_NONE
)
735 e
->flags
= PVSCSI_FLAG_CMD_DIR_NONE
;
739 if (pvscsi_map_buffers(adapter
, ctx
, cmd
, e
) != 0) {
740 if (cmd
->sense_buffer
) {
741 pci_unmap_single(adapter
->dev
, ctx
->sensePA
,
742 SCSI_SENSE_BUFFERSIZE
,
749 e
->context
= pvscsi_map_context(adapter
, ctx
);
758 static int pvscsi_queue_lck(struct scsi_cmnd
*cmd
, void (*done
)(struct scsi_cmnd
*))
760 struct Scsi_Host
*host
= cmd
->device
->host
;
761 struct pvscsi_adapter
*adapter
= shost_priv(host
);
762 struct pvscsi_ctx
*ctx
;
765 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
767 ctx
= pvscsi_acquire_context(adapter
, cmd
);
768 if (!ctx
|| pvscsi_queue_ring(adapter
, ctx
, cmd
) != 0) {
770 pvscsi_release_context(adapter
, ctx
);
771 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
772 return SCSI_MLQUEUE_HOST_BUSY
;
775 cmd
->scsi_done
= done
;
777 dev_dbg(&cmd
->device
->sdev_gendev
,
778 "queued cmd %p, ctx %p, op=%x\n", cmd
, ctx
, cmd
->cmnd
[0]);
780 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
782 pvscsi_kick_io(adapter
, cmd
->cmnd
[0]);
787 static DEF_SCSI_QCMD(pvscsi_queue
)
789 static int pvscsi_abort(struct scsi_cmnd
*cmd
)
791 struct pvscsi_adapter
*adapter
= shost_priv(cmd
->device
->host
);
792 struct pvscsi_ctx
*ctx
;
794 int result
= SUCCESS
;
795 DECLARE_COMPLETION_ONSTACK(abort_cmp
);
798 scmd_printk(KERN_DEBUG
, cmd
, "task abort on host %u, %p\n",
799 adapter
->host
->host_no
, cmd
);
801 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
804 * Poll the completion ring first - we might be trying to abort
805 * a command that is waiting to be dispatched in the completion ring.
807 pvscsi_process_completion_ring(adapter
);
810 * If there is no context for the command, it either already succeeded
811 * or else was never properly issued. Not our problem.
813 ctx
= pvscsi_find_context(adapter
, cmd
);
815 scmd_printk(KERN_DEBUG
, cmd
, "Failed to abort cmd %p\n", cmd
);
820 * Mark that the command has been requested to be aborted and issue
823 ctx
->abort_cmp
= &abort_cmp
;
825 pvscsi_abort_cmd(adapter
, ctx
);
826 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
827 /* Wait for 2 secs for the completion. */
828 done
= wait_for_completion_timeout(&abort_cmp
, msecs_to_jiffies(2000));
829 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
833 * Failed to abort the command, unmark the fact that it
834 * was requested to be aborted.
836 ctx
->abort_cmp
= NULL
;
838 scmd_printk(KERN_DEBUG
, cmd
,
839 "Failed to get completion for aborted cmd %p\n",
845 * Successfully aborted the command.
847 cmd
->result
= (DID_ABORT
<< 16);
851 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
856 * Abort all outstanding requests. This is only safe to use if the completion
857 * ring will never be walked again or the device has been reset, because it
858 * destroys the 1-1 mapping between context field passed to emulation and our
861 static void pvscsi_reset_all(struct pvscsi_adapter
*adapter
)
865 for (i
= 0; i
< adapter
->req_depth
; i
++) {
866 struct pvscsi_ctx
*ctx
= &adapter
->cmd_map
[i
];
867 struct scsi_cmnd
*cmd
= ctx
->cmd
;
869 scmd_printk(KERN_ERR
, cmd
,
870 "Forced reset on cmd %p\n", cmd
);
871 pvscsi_unmap_buffers(adapter
, ctx
);
872 pvscsi_release_context(adapter
, ctx
);
873 cmd
->result
= (DID_RESET
<< 16);
879 static int pvscsi_host_reset(struct scsi_cmnd
*cmd
)
881 struct Scsi_Host
*host
= cmd
->device
->host
;
882 struct pvscsi_adapter
*adapter
= shost_priv(host
);
886 scmd_printk(KERN_INFO
, cmd
, "SCSI Host reset\n");
888 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
890 use_msg
= adapter
->use_msg
;
893 adapter
->use_msg
= 0;
894 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
897 * Now that we know that the ISR won't add more work on the
898 * workqueue we can safely flush any outstanding work.
900 flush_workqueue(adapter
->workqueue
);
901 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
905 * We're going to tear down the entire ring structure and set it back
906 * up, so stalling new requests until all completions are flushed and
907 * the rings are back in place.
910 pvscsi_process_request_ring(adapter
);
912 ll_adapter_reset(adapter
);
915 * Now process any completions. Note we do this AFTER adapter reset,
916 * which is strange, but stops races where completions get posted
917 * between processing the ring and issuing the reset. The backend will
918 * not touch the ring memory after reset, so the immediately pre-reset
919 * completion ring state is still valid.
921 pvscsi_process_completion_ring(adapter
);
923 pvscsi_reset_all(adapter
);
924 adapter
->use_msg
= use_msg
;
925 pvscsi_setup_all_rings(adapter
);
926 pvscsi_unmask_intr(adapter
);
928 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
933 static int pvscsi_bus_reset(struct scsi_cmnd
*cmd
)
935 struct Scsi_Host
*host
= cmd
->device
->host
;
936 struct pvscsi_adapter
*adapter
= shost_priv(host
);
939 scmd_printk(KERN_INFO
, cmd
, "SCSI Bus reset\n");
942 * We don't want to queue new requests for this bus after
943 * flushing all pending requests to emulation, since new
944 * requests could then sneak in during this bus reset phase,
945 * so take the lock now.
947 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
949 pvscsi_process_request_ring(adapter
);
950 ll_bus_reset(adapter
);
951 pvscsi_process_completion_ring(adapter
);
953 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
958 static int pvscsi_device_reset(struct scsi_cmnd
*cmd
)
960 struct Scsi_Host
*host
= cmd
->device
->host
;
961 struct pvscsi_adapter
*adapter
= shost_priv(host
);
964 scmd_printk(KERN_INFO
, cmd
, "SCSI device reset on scsi%u:%u\n",
965 host
->host_no
, cmd
->device
->id
);
968 * We don't want to queue new requests for this device after flushing
969 * all pending requests to emulation, since new requests could then
970 * sneak in during this device reset phase, so take the lock now.
972 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
974 pvscsi_process_request_ring(adapter
);
975 ll_device_reset(adapter
, cmd
->device
->id
);
976 pvscsi_process_completion_ring(adapter
);
978 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
983 static struct scsi_host_template pvscsi_template
;
985 static const char *pvscsi_info(struct Scsi_Host
*host
)
987 struct pvscsi_adapter
*adapter
= shost_priv(host
);
988 static char buf
[256];
990 sprintf(buf
, "VMware PVSCSI storage adapter rev %d, req/cmp/msg rings: "
991 "%u/%u/%u pages, cmd_per_lun=%u", adapter
->rev
,
992 adapter
->req_pages
, adapter
->cmp_pages
, adapter
->msg_pages
,
993 pvscsi_template
.cmd_per_lun
);
998 static struct scsi_host_template pvscsi_template
= {
999 .module
= THIS_MODULE
,
1000 .name
= "VMware PVSCSI Host Adapter",
1001 .proc_name
= "vmw_pvscsi",
1002 .info
= pvscsi_info
,
1003 .queuecommand
= pvscsi_queue
,
1005 .sg_tablesize
= PVSCSI_MAX_NUM_SG_ENTRIES_PER_SEGMENT
,
1006 .dma_boundary
= UINT_MAX
,
1007 .max_sectors
= 0xffff,
1008 .use_clustering
= ENABLE_CLUSTERING
,
1009 .change_queue_depth
= pvscsi_change_queue_depth
,
1010 .eh_abort_handler
= pvscsi_abort
,
1011 .eh_device_reset_handler
= pvscsi_device_reset
,
1012 .eh_bus_reset_handler
= pvscsi_bus_reset
,
1013 .eh_host_reset_handler
= pvscsi_host_reset
,
1016 static void pvscsi_process_msg(const struct pvscsi_adapter
*adapter
,
1017 const struct PVSCSIRingMsgDesc
*e
)
1019 struct PVSCSIRingsState
*s
= adapter
->rings_state
;
1020 struct Scsi_Host
*host
= adapter
->host
;
1021 struct scsi_device
*sdev
;
1023 printk(KERN_INFO
"vmw_pvscsi: msg type: 0x%x - MSG RING: %u/%u (%u) \n",
1024 e
->type
, s
->msgProdIdx
, s
->msgConsIdx
, s
->msgNumEntriesLog2
);
1026 BUILD_BUG_ON(PVSCSI_MSG_LAST
!= 2);
1028 if (e
->type
== PVSCSI_MSG_DEV_ADDED
) {
1029 struct PVSCSIMsgDescDevStatusChanged
*desc
;
1030 desc
= (struct PVSCSIMsgDescDevStatusChanged
*)e
;
1033 "vmw_pvscsi: msg: device added at scsi%u:%u:%u\n",
1034 desc
->bus
, desc
->target
, desc
->lun
[1]);
1036 if (!scsi_host_get(host
))
1039 sdev
= scsi_device_lookup(host
, desc
->bus
, desc
->target
,
1042 printk(KERN_INFO
"vmw_pvscsi: device already exists\n");
1043 scsi_device_put(sdev
);
1045 scsi_add_device(adapter
->host
, desc
->bus
,
1046 desc
->target
, desc
->lun
[1]);
1048 scsi_host_put(host
);
1049 } else if (e
->type
== PVSCSI_MSG_DEV_REMOVED
) {
1050 struct PVSCSIMsgDescDevStatusChanged
*desc
;
1051 desc
= (struct PVSCSIMsgDescDevStatusChanged
*)e
;
1054 "vmw_pvscsi: msg: device removed at scsi%u:%u:%u\n",
1055 desc
->bus
, desc
->target
, desc
->lun
[1]);
1057 if (!scsi_host_get(host
))
1060 sdev
= scsi_device_lookup(host
, desc
->bus
, desc
->target
,
1063 scsi_remove_device(sdev
);
1064 scsi_device_put(sdev
);
1067 "vmw_pvscsi: failed to lookup scsi%u:%u:%u\n",
1068 desc
->bus
, desc
->target
, desc
->lun
[1]);
1070 scsi_host_put(host
);
1074 static int pvscsi_msg_pending(const struct pvscsi_adapter
*adapter
)
1076 struct PVSCSIRingsState
*s
= adapter
->rings_state
;
1078 return s
->msgProdIdx
!= s
->msgConsIdx
;
1081 static void pvscsi_process_msg_ring(const struct pvscsi_adapter
*adapter
)
1083 struct PVSCSIRingsState
*s
= adapter
->rings_state
;
1084 struct PVSCSIRingMsgDesc
*ring
= adapter
->msg_ring
;
1085 u32 msg_entries
= s
->msgNumEntriesLog2
;
1087 while (pvscsi_msg_pending(adapter
)) {
1088 struct PVSCSIRingMsgDesc
*e
= ring
+ (s
->msgConsIdx
&
1092 pvscsi_process_msg(adapter
, e
);
1098 static void pvscsi_msg_workqueue_handler(struct work_struct
*data
)
1100 struct pvscsi_adapter
*adapter
;
1102 adapter
= container_of(data
, struct pvscsi_adapter
, work
);
1104 pvscsi_process_msg_ring(adapter
);
1107 static int pvscsi_setup_msg_workqueue(struct pvscsi_adapter
*adapter
)
1111 if (!pvscsi_use_msg
)
1114 pvscsi_reg_write(adapter
, PVSCSI_REG_OFFSET_COMMAND
,
1115 PVSCSI_CMD_SETUP_MSG_RING
);
1117 if (pvscsi_reg_read(adapter
, PVSCSI_REG_OFFSET_COMMAND_STATUS
) == -1)
1120 snprintf(name
, sizeof(name
),
1121 "vmw_pvscsi_wq_%u", adapter
->host
->host_no
);
1123 adapter
->workqueue
= create_singlethread_workqueue(name
);
1124 if (!adapter
->workqueue
) {
1125 printk(KERN_ERR
"vmw_pvscsi: failed to create work queue\n");
1128 INIT_WORK(&adapter
->work
, pvscsi_msg_workqueue_handler
);
1133 static bool pvscsi_setup_req_threshold(struct pvscsi_adapter
*adapter
,
1138 if (!pvscsi_use_req_threshold
)
1141 pvscsi_reg_write(adapter
, PVSCSI_REG_OFFSET_COMMAND
,
1142 PVSCSI_CMD_SETUP_REQCALLTHRESHOLD
);
1143 val
= pvscsi_reg_read(adapter
, PVSCSI_REG_OFFSET_COMMAND_STATUS
);
1145 printk(KERN_INFO
"vmw_pvscsi: device does not support req_threshold\n");
1148 struct PVSCSICmdDescSetupReqCall cmd_msg
= { 0 };
1149 cmd_msg
.enable
= enable
;
1151 "vmw_pvscsi: %sabling reqCallThreshold\n",
1152 enable
? "en" : "dis");
1153 pvscsi_write_cmd_desc(adapter
,
1154 PVSCSI_CMD_SETUP_REQCALLTHRESHOLD
,
1155 &cmd_msg
, sizeof(cmd_msg
));
1156 return pvscsi_reg_read(adapter
,
1157 PVSCSI_REG_OFFSET_COMMAND_STATUS
) != 0;
1161 static irqreturn_t
pvscsi_isr(int irq
, void *devp
)
1163 struct pvscsi_adapter
*adapter
= devp
;
1166 if (adapter
->use_msi
|| adapter
->use_msix
)
1169 u32 val
= pvscsi_read_intr_status(adapter
);
1170 handled
= (val
& PVSCSI_INTR_ALL_SUPPORTED
) != 0;
1172 pvscsi_write_intr_status(devp
, val
);
1176 unsigned long flags
;
1178 spin_lock_irqsave(&adapter
->hw_lock
, flags
);
1180 pvscsi_process_completion_ring(adapter
);
1181 if (adapter
->use_msg
&& pvscsi_msg_pending(adapter
))
1182 queue_work(adapter
->workqueue
, &adapter
->work
);
1184 spin_unlock_irqrestore(&adapter
->hw_lock
, flags
);
1187 return IRQ_RETVAL(handled
);
1190 static void pvscsi_free_sgls(const struct pvscsi_adapter
*adapter
)
1192 struct pvscsi_ctx
*ctx
= adapter
->cmd_map
;
1195 for (i
= 0; i
< adapter
->req_depth
; ++i
, ++ctx
)
1196 free_pages((unsigned long)ctx
->sgl
, get_order(SGL_SIZE
));
1199 static int pvscsi_setup_msix(const struct pvscsi_adapter
*adapter
,
1202 struct msix_entry entry
= { 0, PVSCSI_VECTOR_COMPLETION
};
1205 ret
= pci_enable_msix_exact(adapter
->dev
, &entry
, 1);
1209 *irq
= entry
.vector
;
1214 static void pvscsi_shutdown_intr(struct pvscsi_adapter
*adapter
)
1217 free_irq(adapter
->irq
, adapter
);
1220 if (adapter
->use_msi
) {
1221 pci_disable_msi(adapter
->dev
);
1222 adapter
->use_msi
= 0;
1223 } else if (adapter
->use_msix
) {
1224 pci_disable_msix(adapter
->dev
);
1225 adapter
->use_msix
= 0;
1229 static void pvscsi_release_resources(struct pvscsi_adapter
*adapter
)
1231 pvscsi_shutdown_intr(adapter
);
1233 if (adapter
->workqueue
)
1234 destroy_workqueue(adapter
->workqueue
);
1236 if (adapter
->mmioBase
)
1237 pci_iounmap(adapter
->dev
, adapter
->mmioBase
);
1239 pci_release_regions(adapter
->dev
);
1241 if (adapter
->cmd_map
) {
1242 pvscsi_free_sgls(adapter
);
1243 kfree(adapter
->cmd_map
);
1246 if (adapter
->rings_state
)
1247 pci_free_consistent(adapter
->dev
, PAGE_SIZE
,
1248 adapter
->rings_state
, adapter
->ringStatePA
);
1250 if (adapter
->req_ring
)
1251 pci_free_consistent(adapter
->dev
,
1252 adapter
->req_pages
* PAGE_SIZE
,
1253 adapter
->req_ring
, adapter
->reqRingPA
);
1255 if (adapter
->cmp_ring
)
1256 pci_free_consistent(adapter
->dev
,
1257 adapter
->cmp_pages
* PAGE_SIZE
,
1258 adapter
->cmp_ring
, adapter
->cmpRingPA
);
1260 if (adapter
->msg_ring
)
1261 pci_free_consistent(adapter
->dev
,
1262 adapter
->msg_pages
* PAGE_SIZE
,
1263 adapter
->msg_ring
, adapter
->msgRingPA
);
1267 * Allocate scatter gather lists.
1269 * These are statically allocated. Trying to be clever was not worth it.
1271 * Dynamic allocation can fail, and we can't go deep into the memory
1272 * allocator, since we're a SCSI driver, and trying too hard to allocate
1273 * memory might generate disk I/O. We also don't want to fail disk I/O
1274 * in that case because we can't get an allocation - the I/O could be
1275 * trying to swap out data to free memory. Since that is pathological,
1276 * just use a statically allocated scatter list.
1279 static int pvscsi_allocate_sg(struct pvscsi_adapter
*adapter
)
1281 struct pvscsi_ctx
*ctx
;
1284 ctx
= adapter
->cmd_map
;
1285 BUILD_BUG_ON(sizeof(struct pvscsi_sg_list
) > SGL_SIZE
);
1287 for (i
= 0; i
< adapter
->req_depth
; ++i
, ++ctx
) {
1288 ctx
->sgl
= (void *)__get_free_pages(GFP_KERNEL
,
1289 get_order(SGL_SIZE
));
1291 BUG_ON(!IS_ALIGNED(((unsigned long)ctx
->sgl
), PAGE_SIZE
));
1293 for (; i
>= 0; --i
, --ctx
) {
1294 free_pages((unsigned long)ctx
->sgl
,
1295 get_order(SGL_SIZE
));
1306 * Query the device, fetch the config info and return the
1307 * maximum number of targets on the adapter. In case of
1308 * failure due to any reason return default i.e. 16.
1310 static u32
pvscsi_get_max_targets(struct pvscsi_adapter
*adapter
)
1312 struct PVSCSICmdDescConfigCmd cmd
;
1313 struct PVSCSIConfigPageHeader
*header
;
1315 dma_addr_t configPagePA
;
1319 dev
= pvscsi_dev(adapter
);
1320 config_page
= pci_alloc_consistent(adapter
->dev
, PAGE_SIZE
,
1323 dev_warn(dev
, "vmw_pvscsi: failed to allocate memory for config page\n");
1326 BUG_ON(configPagePA
& ~PAGE_MASK
);
1328 /* Fetch config info from the device. */
1329 cmd
.configPageAddress
= ((u64
)PVSCSI_CONFIG_CONTROLLER_ADDRESS
) << 32;
1330 cmd
.configPageNum
= PVSCSI_CONFIG_PAGE_CONTROLLER
;
1331 cmd
.cmpAddr
= configPagePA
;
1335 * Mark the completion page header with error values. If the device
1336 * completes the command successfully, it sets the status values to
1339 header
= config_page
;
1340 memset(header
, 0, sizeof *header
);
1341 header
->hostStatus
= BTSTAT_INVPARAM
;
1342 header
->scsiStatus
= SDSTAT_CHECK
;
1344 pvscsi_write_cmd_desc(adapter
, PVSCSI_CMD_CONFIG
, &cmd
, sizeof cmd
);
1346 if (header
->hostStatus
== BTSTAT_SUCCESS
&&
1347 header
->scsiStatus
== SDSTAT_GOOD
) {
1348 struct PVSCSIConfigPageController
*config
;
1350 config
= config_page
;
1351 numPhys
= config
->numPhys
;
1353 dev_warn(dev
, "vmw_pvscsi: PVSCSI_CMD_CONFIG failed. hostStatus = 0x%x, scsiStatus = 0x%x\n",
1354 header
->hostStatus
, header
->scsiStatus
);
1355 pci_free_consistent(adapter
->dev
, PAGE_SIZE
, config_page
, configPagePA
);
1360 static int pvscsi_probe(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
1362 struct pvscsi_adapter
*adapter
;
1363 struct pvscsi_adapter adapter_temp
;
1364 struct Scsi_Host
*host
= NULL
;
1366 unsigned long flags
= 0;
1372 if (pci_enable_device(pdev
))
1375 if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(64)) == 0 &&
1376 pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(64)) == 0) {
1377 printk(KERN_INFO
"vmw_pvscsi: using 64bit dma\n");
1378 } else if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(32)) == 0 &&
1379 pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32)) == 0) {
1380 printk(KERN_INFO
"vmw_pvscsi: using 32bit dma\n");
1382 printk(KERN_ERR
"vmw_pvscsi: failed to set DMA mask\n");
1383 goto out_disable_device
;
1387 * Let's use a temp pvscsi_adapter struct until we find the number of
1388 * targets on the adapter, after that we will switch to the real
1391 adapter
= &adapter_temp
;
1392 memset(adapter
, 0, sizeof(*adapter
));
1393 adapter
->dev
= pdev
;
1394 adapter
->rev
= pdev
->revision
;
1396 if (pci_request_regions(pdev
, "vmw_pvscsi")) {
1397 printk(KERN_ERR
"vmw_pvscsi: pci memory selection failed\n");
1398 goto out_disable_device
;
1401 for (i
= 0; i
< DEVICE_COUNT_RESOURCE
; i
++) {
1402 if ((pci_resource_flags(pdev
, i
) & PCI_BASE_ADDRESS_SPACE_IO
))
1405 if (pci_resource_len(pdev
, i
) < PVSCSI_MEM_SPACE_SIZE
)
1411 if (i
== DEVICE_COUNT_RESOURCE
) {
1413 "vmw_pvscsi: adapter has no suitable MMIO region\n");
1414 goto out_release_resources_and_disable
;
1417 adapter
->mmioBase
= pci_iomap(pdev
, i
, PVSCSI_MEM_SPACE_SIZE
);
1419 if (!adapter
->mmioBase
) {
1421 "vmw_pvscsi: can't iomap for BAR %d memsize %lu\n",
1422 i
, PVSCSI_MEM_SPACE_SIZE
);
1423 goto out_release_resources_and_disable
;
1426 pci_set_master(pdev
);
1429 * Ask the device for max number of targets before deciding the
1430 * default pvscsi_ring_pages value.
1432 max_id
= pvscsi_get_max_targets(adapter
);
1433 printk(KERN_INFO
"vmw_pvscsi: max_id: %u\n", max_id
);
1435 if (pvscsi_ring_pages
== 0)
1437 * Set the right default value. Up to 16 it is 8, above it is
1440 pvscsi_ring_pages
= (max_id
> 16) ?
1441 PVSCSI_SETUP_RINGS_MAX_NUM_PAGES
:
1442 PVSCSI_DEFAULT_NUM_PAGES_PER_RING
;
1444 "vmw_pvscsi: setting ring_pages to %d\n",
1447 pvscsi_template
.can_queue
=
1448 min(PVSCSI_MAX_NUM_PAGES_REQ_RING
, pvscsi_ring_pages
) *
1449 PVSCSI_MAX_NUM_REQ_ENTRIES_PER_PAGE
;
1450 pvscsi_template
.cmd_per_lun
=
1451 min(pvscsi_template
.can_queue
, pvscsi_cmd_per_lun
);
1452 host
= scsi_host_alloc(&pvscsi_template
, sizeof(struct pvscsi_adapter
));
1454 printk(KERN_ERR
"vmw_pvscsi: failed to allocate host\n");
1455 goto out_release_resources_and_disable
;
1459 * Let's use the real pvscsi_adapter struct here onwards.
1461 adapter
= shost_priv(host
);
1462 memset(adapter
, 0, sizeof(*adapter
));
1463 adapter
->dev
= pdev
;
1464 adapter
->host
= host
;
1466 * Copy back what we already have to the allocated adapter struct.
1468 adapter
->rev
= adapter_temp
.rev
;
1469 adapter
->mmioBase
= adapter_temp
.mmioBase
;
1471 spin_lock_init(&adapter
->hw_lock
);
1472 host
->max_channel
= 0;
1474 host
->max_cmd_len
= 16;
1475 host
->max_id
= max_id
;
1477 pci_set_drvdata(pdev
, host
);
1479 ll_adapter_reset(adapter
);
1481 adapter
->use_msg
= pvscsi_setup_msg_workqueue(adapter
);
1483 error
= pvscsi_allocate_rings(adapter
);
1485 printk(KERN_ERR
"vmw_pvscsi: unable to allocate ring memory\n");
1486 goto out_release_resources
;
1490 * From this point on we should reset the adapter if anything goes
1493 pvscsi_setup_all_rings(adapter
);
1495 adapter
->cmd_map
= kcalloc(adapter
->req_depth
,
1496 sizeof(struct pvscsi_ctx
), GFP_KERNEL
);
1497 if (!adapter
->cmd_map
) {
1498 printk(KERN_ERR
"vmw_pvscsi: failed to allocate memory.\n");
1500 goto out_reset_adapter
;
1503 INIT_LIST_HEAD(&adapter
->cmd_pool
);
1504 for (i
= 0; i
< adapter
->req_depth
; i
++) {
1505 struct pvscsi_ctx
*ctx
= adapter
->cmd_map
+ i
;
1506 list_add(&ctx
->list
, &adapter
->cmd_pool
);
1509 error
= pvscsi_allocate_sg(adapter
);
1511 printk(KERN_ERR
"vmw_pvscsi: unable to allocate s/g table\n");
1512 goto out_reset_adapter
;
1515 if (!pvscsi_disable_msix
&&
1516 pvscsi_setup_msix(adapter
, &adapter
->irq
) == 0) {
1517 printk(KERN_INFO
"vmw_pvscsi: using MSI-X\n");
1518 adapter
->use_msix
= 1;
1519 } else if (!pvscsi_disable_msi
&& pci_enable_msi(pdev
) == 0) {
1520 printk(KERN_INFO
"vmw_pvscsi: using MSI\n");
1521 adapter
->use_msi
= 1;
1522 adapter
->irq
= pdev
->irq
;
1524 printk(KERN_INFO
"vmw_pvscsi: using INTx\n");
1525 adapter
->irq
= pdev
->irq
;
1526 flags
= IRQF_SHARED
;
1529 adapter
->use_req_threshold
= pvscsi_setup_req_threshold(adapter
, true);
1530 printk(KERN_DEBUG
"vmw_pvscsi: driver-based request coalescing %sabled\n",
1531 adapter
->use_req_threshold
? "en" : "dis");
1533 error
= request_irq(adapter
->irq
, pvscsi_isr
, flags
,
1534 "vmw_pvscsi", adapter
);
1537 "vmw_pvscsi: unable to request IRQ: %d\n", error
);
1539 goto out_reset_adapter
;
1542 error
= scsi_add_host(host
, &pdev
->dev
);
1545 "vmw_pvscsi: scsi_add_host failed: %d\n", error
);
1546 goto out_reset_adapter
;
1549 dev_info(&pdev
->dev
, "VMware PVSCSI rev %d host #%u\n",
1550 adapter
->rev
, host
->host_no
);
1552 pvscsi_unmask_intr(adapter
);
1554 scsi_scan_host(host
);
1559 ll_adapter_reset(adapter
);
1560 out_release_resources
:
1561 pvscsi_release_resources(adapter
);
1562 scsi_host_put(host
);
1564 pci_disable_device(pdev
);
1568 out_release_resources_and_disable
:
1569 pvscsi_release_resources(adapter
);
1570 goto out_disable_device
;
1573 static void __pvscsi_shutdown(struct pvscsi_adapter
*adapter
)
1575 pvscsi_mask_intr(adapter
);
1577 if (adapter
->workqueue
)
1578 flush_workqueue(adapter
->workqueue
);
1580 pvscsi_shutdown_intr(adapter
);
1582 pvscsi_process_request_ring(adapter
);
1583 pvscsi_process_completion_ring(adapter
);
1584 ll_adapter_reset(adapter
);
1587 static void pvscsi_shutdown(struct pci_dev
*dev
)
1589 struct Scsi_Host
*host
= pci_get_drvdata(dev
);
1590 struct pvscsi_adapter
*adapter
= shost_priv(host
);
1592 __pvscsi_shutdown(adapter
);
1595 static void pvscsi_remove(struct pci_dev
*pdev
)
1597 struct Scsi_Host
*host
= pci_get_drvdata(pdev
);
1598 struct pvscsi_adapter
*adapter
= shost_priv(host
);
1600 scsi_remove_host(host
);
1602 __pvscsi_shutdown(adapter
);
1603 pvscsi_release_resources(adapter
);
1605 scsi_host_put(host
);
1607 pci_disable_device(pdev
);
1610 static struct pci_driver pvscsi_pci_driver
= {
1611 .name
= "vmw_pvscsi",
1612 .id_table
= pvscsi_pci_tbl
,
1613 .probe
= pvscsi_probe
,
1614 .remove
= pvscsi_remove
,
1615 .shutdown
= pvscsi_shutdown
,
1618 static int __init
pvscsi_init(void)
1620 pr_info("%s - version %s\n",
1621 PVSCSI_LINUX_DRIVER_DESC
, PVSCSI_DRIVER_VERSION_STRING
);
1622 return pci_register_driver(&pvscsi_pci_driver
);
1625 static void __exit
pvscsi_exit(void)
1627 pci_unregister_driver(&pvscsi_pci_driver
);
1630 module_init(pvscsi_init
);
1631 module_exit(pvscsi_exit
);