Lines Matching refs:adapter
151 pvscsi_dev(const struct pvscsi_adapter *adapter)
153 return &(adapter->dev->dev);
157 pvscsi_find_context(const struct pvscsi_adapter *adapter, struct scsi_cmnd *cmd)
161 end = &adapter->cmd_map[adapter->req_depth];
162 for (ctx = adapter->cmd_map; ctx < end; ctx++)
170 pvscsi_acquire_context(struct pvscsi_adapter *adapter, struct scsi_cmnd *cmd)
174 if (list_empty(&adapter->cmd_pool))
177 ctx = list_first_entry(&adapter->cmd_pool, struct pvscsi_ctx, list);
184 static void pvscsi_release_context(struct pvscsi_adapter *adapter,
189 list_add(&ctx->list, &adapter->cmd_pool);
197 static u64 pvscsi_map_context(const struct pvscsi_adapter *adapter,
200 return ctx - adapter->cmd_map + 1;
204 pvscsi_get_context(const struct pvscsi_adapter *adapter, u64 context)
206 return &adapter->cmd_map[context - 1];
209 static void pvscsi_reg_write(const struct pvscsi_adapter *adapter,
212 writel(val, adapter->mmioBase + offset);
215 static u32 pvscsi_reg_read(const struct pvscsi_adapter *adapter, u32 offset)
217 return readl(adapter->mmioBase + offset);
220 static u32 pvscsi_read_intr_status(const struct pvscsi_adapter *adapter)
222 return pvscsi_reg_read(adapter, PVSCSI_REG_OFFSET_INTR_STATUS);
225 static void pvscsi_write_intr_status(const struct pvscsi_adapter *adapter,
228 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_INTR_STATUS, val);
231 static void pvscsi_unmask_intr(const struct pvscsi_adapter *adapter)
236 if (adapter->use_msg)
239 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_INTR_MASK, intr_bits);
242 static void pvscsi_mask_intr(const struct pvscsi_adapter *adapter)
244 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_INTR_MASK, 0);
247 static void pvscsi_write_cmd_desc(const struct pvscsi_adapter *adapter,
254 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_COMMAND, cmd);
256 pvscsi_reg_write(adapter,
260 static void pvscsi_abort_cmd(const struct pvscsi_adapter *adapter,
266 cmd.context = pvscsi_map_context(adapter, ctx);
268 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_ABORT_CMD, &cmd, sizeof(cmd));
271 static void pvscsi_kick_rw_io(const struct pvscsi_adapter *adapter)
273 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_KICK_RW_IO, 0);
276 static void pvscsi_process_request_ring(const struct pvscsi_adapter *adapter)
278 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_KICK_NON_RW_IO, 0);
289 static void pvscsi_kick_io(const struct pvscsi_adapter *adapter,
293 struct PVSCSIRingsState *s = adapter->rings_state;
295 if (!adapter->use_req_threshold ||
297 pvscsi_kick_rw_io(adapter);
299 pvscsi_process_request_ring(adapter);
303 static void ll_adapter_reset(const struct pvscsi_adapter *adapter)
305 dev_dbg(pvscsi_dev(adapter), "Adapter Reset on %p\n", adapter);
307 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_ADAPTER_RESET, NULL, 0);
310 static void ll_bus_reset(const struct pvscsi_adapter *adapter)
312 dev_dbg(pvscsi_dev(adapter), "Resetting bus on %p\n", adapter);
314 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_RESET_BUS, NULL, 0);
317 static void ll_device_reset(const struct pvscsi_adapter *adapter, u32 target)
321 dev_dbg(pvscsi_dev(adapter), "Resetting device: target=%u\n", target);
325 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_RESET_DEVICE,
349 static int pvscsi_map_buffers(struct pvscsi_adapter *adapter,
375 ctx->sglPA = dma_map_single(&adapter->dev->dev,
377 if (dma_mapping_error(&adapter->dev->dev, ctx->sglPA)) {
392 ctx->dataPA = dma_map_single(&adapter->dev->dev, sg, bufflen,
394 if (dma_mapping_error(&adapter->dev->dev, ctx->dataPA)) {
416 static void pvscsi_unmap_buffers(const struct pvscsi_adapter *adapter,
431 dma_unmap_single(&adapter->dev->dev, ctx->sglPA,
436 dma_unmap_single(&adapter->dev->dev, ctx->dataPA,
440 dma_unmap_single(&adapter->dev->dev, ctx->sensePA,
444 static int pvscsi_allocate_rings(struct pvscsi_adapter *adapter)
446 adapter->rings_state = dma_alloc_coherent(&adapter->dev->dev, PAGE_SIZE,
447 &adapter->ringStatePA, GFP_KERNEL);
448 if (!adapter->rings_state)
451 adapter->req_pages = min(PVSCSI_MAX_NUM_PAGES_REQ_RING,
453 adapter->req_depth = adapter->req_pages
455 adapter->req_ring = dma_alloc_coherent(&adapter->dev->dev,
456 adapter->req_pages * PAGE_SIZE, &adapter->reqRingPA,
458 if (!adapter->req_ring)
461 adapter->cmp_pages = min(PVSCSI_MAX_NUM_PAGES_CMP_RING,
463 adapter->cmp_ring = dma_alloc_coherent(&adapter->dev->dev,
464 adapter->cmp_pages * PAGE_SIZE, &adapter->cmpRingPA,
466 if (!adapter->cmp_ring)
469 BUG_ON(!IS_ALIGNED(adapter->ringStatePA, PAGE_SIZE));
470 BUG_ON(!IS_ALIGNED(adapter->reqRingPA, PAGE_SIZE));
471 BUG_ON(!IS_ALIGNED(adapter->cmpRingPA, PAGE_SIZE));
473 if (!adapter->use_msg)
476 adapter->msg_pages = min(PVSCSI_MAX_NUM_PAGES_MSG_RING,
478 adapter->msg_ring = dma_alloc_coherent(&adapter->dev->dev,
479 adapter->msg_pages * PAGE_SIZE, &adapter->msgRingPA,
481 if (!adapter->msg_ring)
483 BUG_ON(!IS_ALIGNED(adapter->msgRingPA, PAGE_SIZE));
488 static void pvscsi_setup_all_rings(const struct pvscsi_adapter *adapter)
494 cmd.ringsStatePPN = adapter->ringStatePA >> PAGE_SHIFT;
495 cmd.reqRingNumPages = adapter->req_pages;
496 cmd.cmpRingNumPages = adapter->cmp_pages;
498 base = adapter->reqRingPA;
499 for (i = 0; i < adapter->req_pages; i++) {
504 base = adapter->cmpRingPA;
505 for (i = 0; i < adapter->cmp_pages; i++) {
510 memset(adapter->rings_state, 0, PAGE_SIZE);
511 memset(adapter->req_ring, 0, adapter->req_pages * PAGE_SIZE);
512 memset(adapter->cmp_ring, 0, adapter->cmp_pages * PAGE_SIZE);
514 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_SETUP_RINGS,
517 if (adapter->use_msg) {
520 cmd_msg.numPages = adapter->msg_pages;
522 base = adapter->msgRingPA;
523 for (i = 0; i < adapter->msg_pages; i++) {
527 memset(adapter->msg_ring, 0, adapter->msg_pages * PAGE_SIZE);
529 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_SETUP_MSG_RING,
545 static void pvscsi_complete_request(struct pvscsi_adapter *adapter,
554 ctx = pvscsi_get_context(adapter, e->context);
557 pvscsi_unmap_buffers(adapter, ctx);
560 pvscsi_release_context(adapter, ctx);
667 static void pvscsi_process_completion_ring(struct pvscsi_adapter *adapter)
669 struct PVSCSIRingsState *s = adapter->rings_state;
670 struct PVSCSIRingCmpDesc *ring = adapter->cmp_ring;
683 pvscsi_complete_request(adapter, e);
698 static int pvscsi_queue_ring(struct pvscsi_adapter *adapter,
706 s = adapter->rings_state;
725 e = adapter->req_ring + (s->reqProdIdx & MASK(req_entries));
733 ctx->sensePA = dma_map_single(&adapter->dev->dev,
736 if (dma_mapping_error(&adapter->dev->dev, ctx->sensePA)) {
763 if (pvscsi_map_buffers(adapter, ctx, cmd, e) != 0) {
765 dma_unmap_single(&adapter->dev->dev, ctx->sensePA,
773 e->context = pvscsi_map_context(adapter, ctx);
785 struct pvscsi_adapter *adapter = shost_priv(host);
790 spin_lock_irqsave(&adapter->hw_lock, flags);
792 ctx = pvscsi_acquire_context(adapter, cmd);
793 if (!ctx || pvscsi_queue_ring(adapter, ctx, cmd) != 0) {
795 pvscsi_release_context(adapter, ctx);
796 spin_unlock_irqrestore(&adapter->hw_lock, flags);
806 spin_unlock_irqrestore(&adapter->hw_lock, flags);
808 pvscsi_kick_io(adapter, op);
817 struct pvscsi_adapter *adapter = shost_priv(cmd->device->host);
825 adapter->host->host_no, cmd);
827 spin_lock_irqsave(&adapter->hw_lock, flags);
833 pvscsi_process_completion_ring(adapter);
839 ctx = pvscsi_find_context(adapter, cmd);
851 pvscsi_abort_cmd(adapter, ctx);
852 spin_unlock_irqrestore(&adapter->hw_lock, flags);
855 spin_lock_irqsave(&adapter->hw_lock, flags);
877 spin_unlock_irqrestore(&adapter->hw_lock, flags);
887 static void pvscsi_reset_all(struct pvscsi_adapter *adapter)
891 for (i = 0; i < adapter->req_depth; i++) {
892 struct pvscsi_ctx *ctx = &adapter->cmd_map[i];
897 pvscsi_unmap_buffers(adapter, ctx);
899 pvscsi_release_context(adapter, ctx);
909 struct pvscsi_adapter *adapter = shost_priv(host);
915 spin_lock_irqsave(&adapter->hw_lock, flags);
917 use_msg = adapter->use_msg;
920 adapter->use_msg = false;
921 spin_unlock_irqrestore(&adapter->hw_lock, flags);
927 flush_workqueue(adapter->workqueue);
928 spin_lock_irqsave(&adapter->hw_lock, flags);
937 pvscsi_process_request_ring(adapter);
939 ll_adapter_reset(adapter);
942 * Now process any completions. Note we do this AFTER adapter reset,
948 pvscsi_process_completion_ring(adapter);
950 pvscsi_reset_all(adapter);
951 adapter->use_msg = use_msg;
952 pvscsi_setup_all_rings(adapter);
953 pvscsi_unmask_intr(adapter);
955 spin_unlock_irqrestore(&adapter->hw_lock, flags);
963 struct pvscsi_adapter *adapter = shost_priv(host);
974 spin_lock_irqsave(&adapter->hw_lock, flags);
976 pvscsi_process_request_ring(adapter);
977 ll_bus_reset(adapter);
978 pvscsi_process_completion_ring(adapter);
980 spin_unlock_irqrestore(&adapter->hw_lock, flags);
988 struct pvscsi_adapter *adapter = shost_priv(host);
999 spin_lock_irqsave(&adapter->hw_lock, flags);
1001 pvscsi_process_request_ring(adapter);
1002 ll_device_reset(adapter, cmd->device->id);
1003 pvscsi_process_completion_ring(adapter);
1005 spin_unlock_irqrestore(&adapter->hw_lock, flags);
1014 struct pvscsi_adapter *adapter = shost_priv(host);
1017 sprintf(buf, "VMware PVSCSI storage adapter rev %d, req/cmp/msg rings: "
1018 "%u/%u/%u pages, cmd_per_lun=%u", adapter->rev,
1019 adapter->req_pages, adapter->cmp_pages, adapter->msg_pages,
1042 static void pvscsi_process_msg(const struct pvscsi_adapter *adapter,
1045 struct PVSCSIRingsState *s = adapter->rings_state;
1046 struct Scsi_Host *host = adapter->host;
1071 scsi_add_device(adapter->host, desc->bus,
1100 static int pvscsi_msg_pending(const struct pvscsi_adapter *adapter)
1102 struct PVSCSIRingsState *s = adapter->rings_state;
1107 static void pvscsi_process_msg_ring(const struct pvscsi_adapter *adapter)
1109 struct PVSCSIRingsState *s = adapter->rings_state;
1110 struct PVSCSIRingMsgDesc *ring = adapter->msg_ring;
1113 while (pvscsi_msg_pending(adapter)) {
1118 pvscsi_process_msg(adapter, e);
1126 struct pvscsi_adapter *adapter;
1128 adapter = container_of(data, struct pvscsi_adapter, work);
1130 pvscsi_process_msg_ring(adapter);
1133 static int pvscsi_setup_msg_workqueue(struct pvscsi_adapter *adapter)
1140 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_COMMAND,
1143 if (pvscsi_reg_read(adapter, PVSCSI_REG_OFFSET_COMMAND_STATUS) == -1)
1147 "vmw_pvscsi_wq_%u", adapter->host->host_no);
1149 adapter->workqueue = create_singlethread_workqueue(name);
1150 if (!adapter->workqueue) {
1154 INIT_WORK(&adapter->work, pvscsi_msg_workqueue_handler);
1159 static bool pvscsi_setup_req_threshold(struct pvscsi_adapter *adapter,
1167 pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_COMMAND,
1169 val = pvscsi_reg_read(adapter, PVSCSI_REG_OFFSET_COMMAND_STATUS);
1179 pvscsi_write_cmd_desc(adapter,
1182 return pvscsi_reg_read(adapter,
1189 struct pvscsi_adapter *adapter = devp;
1192 spin_lock_irqsave(&adapter->hw_lock, flags);
1193 pvscsi_process_completion_ring(adapter);
1194 if (adapter->use_msg && pvscsi_msg_pending(adapter))
1195 queue_work(adapter->workqueue, &adapter->work);
1196 spin_unlock_irqrestore(&adapter->hw_lock, flags);
1203 struct pvscsi_adapter *adapter = devp;
1204 u32 val = pvscsi_read_intr_status(adapter);
1212 static void pvscsi_free_sgls(const struct pvscsi_adapter *adapter)
1214 struct pvscsi_ctx *ctx = adapter->cmd_map;
1217 for (i = 0; i < adapter->req_depth; ++i, ++ctx)
1221 static void pvscsi_shutdown_intr(struct pvscsi_adapter *adapter)
1223 free_irq(pci_irq_vector(adapter->dev, 0), adapter);
1224 pci_free_irq_vectors(adapter->dev);
1227 static void pvscsi_release_resources(struct pvscsi_adapter *adapter)
1229 if (adapter->workqueue)
1230 destroy_workqueue(adapter->workqueue);
1232 if (adapter->mmioBase)
1233 pci_iounmap(adapter->dev, adapter->mmioBase);
1235 pci_release_regions(adapter->dev);
1237 if (adapter->cmd_map) {
1238 pvscsi_free_sgls(adapter);
1239 kfree(adapter->cmd_map);
1242 if (adapter->rings_state)
1243 dma_free_coherent(&adapter->dev->dev, PAGE_SIZE,
1244 adapter->rings_state, adapter->ringStatePA);
1246 if (adapter->req_ring)
1247 dma_free_coherent(&adapter->dev->dev,
1248 adapter->req_pages * PAGE_SIZE,
1249 adapter->req_ring, adapter->reqRingPA);
1251 if (adapter->cmp_ring)
1252 dma_free_coherent(&adapter->dev->dev,
1253 adapter->cmp_pages * PAGE_SIZE,
1254 adapter->cmp_ring, adapter->cmpRingPA);
1256 if (adapter->msg_ring)
1257 dma_free_coherent(&adapter->dev->dev,
1258 adapter->msg_pages * PAGE_SIZE,
1259 adapter->msg_ring, adapter->msgRingPA);
1275 static int pvscsi_allocate_sg(struct pvscsi_adapter *adapter)
1280 ctx = adapter->cmd_map;
1283 for (i = 0; i < adapter->req_depth; ++i, ++ctx) {
1303 * maximum number of targets on the adapter. In case of
1306 static u32 pvscsi_get_max_targets(struct pvscsi_adapter *adapter)
1315 dev = pvscsi_dev(adapter);
1316 config_page = dma_alloc_coherent(&adapter->dev->dev, PAGE_SIZE,
1340 pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_CONFIG, &cmd, sizeof cmd);
1351 dma_free_coherent(&adapter->dev->dev, PAGE_SIZE, config_page,
1360 struct pvscsi_adapter *adapter;
1383 * targets on the adapter, after that we will switch to the real
1386 adapter = &adapter_temp;
1387 memset(adapter, 0, sizeof(*adapter));
1388 adapter->dev = pdev;
1389 adapter->rev = pdev->revision;
1408 "vmw_pvscsi: adapter has no suitable MMIO region\n");
1412 adapter->mmioBase = pci_iomap(pdev, i, PVSCSI_MEM_SPACE_SIZE);
1414 if (!adapter->mmioBase) {
1427 max_id = pvscsi_get_max_targets(adapter);
1456 adapter = shost_priv(host);
1457 memset(adapter, 0, sizeof(*adapter));
1458 adapter->dev = pdev;
1459 adapter->host = host;
1461 * Copy back what we already have to the allocated adapter struct.
1463 adapter->rev = adapter_temp.rev;
1464 adapter->mmioBase = adapter_temp.mmioBase;
1466 spin_lock_init(&adapter->hw_lock);
1474 ll_adapter_reset(adapter);
1476 adapter->use_msg = pvscsi_setup_msg_workqueue(adapter);
1478 error = pvscsi_allocate_rings(adapter);
1485 * From this point on we should reset the adapter if anything goes
1488 pvscsi_setup_all_rings(adapter);
1490 adapter->cmd_map = kcalloc(adapter->req_depth,
1492 if (!adapter->cmd_map) {
1498 INIT_LIST_HEAD(&adapter->cmd_pool);
1499 for (i = 0; i < adapter->req_depth; i++) {
1500 struct pvscsi_ctx *ctx = adapter->cmd_map + i;
1501 list_add(&ctx->list, &adapter->cmd_pool);
1504 error = pvscsi_allocate_sg(adapter);
1515 error = pci_alloc_irq_vectors(adapter->dev, 1, 1, irq_flag);
1519 adapter->use_req_threshold = pvscsi_setup_req_threshold(adapter, true);
1521 adapter->use_req_threshold ? "en" : "dis");
1523 if (adapter->dev->msix_enabled || adapter->dev->msi_enabled) {
1525 adapter->dev->msix_enabled ? "-X" : "");
1527 0, "vmw_pvscsi", adapter);
1531 IRQF_SHARED, "vmw_pvscsi", adapter);
1548 adapter->rev, host->host_no);
1550 pvscsi_unmask_intr(adapter);
1557 ll_adapter_reset(adapter);
1559 pvscsi_shutdown_intr(adapter);
1560 pvscsi_release_resources(adapter);
1568 pvscsi_shutdown_intr(adapter);
1569 pvscsi_release_resources(adapter);
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);
1590 struct pvscsi_adapter *adapter = shost_priv(host);
1592 __pvscsi_shutdown(adapter);
1598 struct pvscsi_adapter *adapter = shost_priv(host);
1602 __pvscsi_shutdown(adapter);
1603 pvscsi_release_resources(adapter);