[Zesty][PATCH 00/44] scsi: cxlflash: update driver (backport)

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
49 messages Options
123
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 00/44] scsi: cxlflash: update driver (backport)

Victor Aoqui
From: Victor Aoqui <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

These cxlflash driver updates are required by IBM team.

Guenter Roeck (1):
  scsi: cxlflash: Select IRQ_POLL

Matthew R. Ochs (32):
  scsi: cxlflash: Refactor context reset to share reset logic
  scsi: cxlflash: Support SQ Command Mode
  scsi: cxlflash: Cleanup prints
  scsi: cxlflash: Enable PCI device ID for future IBM CXL Flash AFU
  scsi: cxlflash: Separate RRQ processing from the RRQ interrupt handler
  scsi: cxlflash: Serialize RRQ access and support offlevel processing
  scsi: cxlflash: Implement IRQ polling for RRQ processing
  scsi: cxlflash: Update sysfs helper routines to pass config structure
  scsi: cxlflash: Support dynamic number of FC ports
  scsi: cxlflash: Remove port configuration assumptions
  scsi: cxlflash: Hide FC internals behind common access routine
  scsi: cxlflash: SISlite updates to support 4 ports
  scsi: cxlflash: Support up to 4 ports
  scsi: cxlflash: Fence EEH during probe
  scsi: cxlflash: Remove unnecessary DMA mapping
  scsi: cxlflash: Fix power-of-two validations
  scsi: cxlflash: Fix warnings/errors
  scsi: cxlflash: Improve asynchronous interrupt processing
  scsi: cxlflash: Add hardware queues attribute
  scsi: cxlflash: Introduce hardware queue steering
  cxl: Enable PCI device IDs for future IBM CXL adapters
  scsi: cxlflash: Separate AFU internal command handling from AFU sync
    specifics
  scsi: cxlflash: Introduce host ioctl support
  scsi: cxlflash: Refactor AFU capability checking
  scsi: cxlflash: Support LUN provisioning
  scsi: cxlflash: Support AFU debug
  scsi: cxlflash: Support WS16 unmap
  scsi: cxlflash: Remove zeroing of private command data
  scsi: cxlflash: Update TMF command processing
  scsi: cxlflash: Avoid double free of character device
  scsi: cxlflash: Update send_tmf() parameters
  scsi: cxlflash: Update debug prints in reset handlers

Uma Krishnan (11):
  scsi: cxlflash: Cancel scheduled workers before stopping AFU
  scsi: cxlflash: Support multiple hardware queues
  scsi: cxlflash: Combine the send queue locks
  scsi: cxlflash: Update cxlflash_afu_sync() to return errno
  scsi: cxlflash: Reset hardware queue context via specified register
  scsi: cxlflash: Schedule asynchronous reset of the host
  scsi: cxlflash: Handle AFU sync failures
  scsi: cxlflash: Track pending scsi commands in each hardware queue
  scsi: cxlflash: Flush pending commands in cleanup path
  scsi: cxlflash: Add scsi command abort handler
  scsi: cxlflash: Create character device to provide host management
    interface

 Documentation/ioctl/ioctl-number.txt |    2 +-
 Documentation/powerpc/cxlflash.txt   |   81 +-
 drivers/misc/cxl/pci.c               |    2 +
 drivers/scsi/cxlflash/Kconfig        |    1 +
 drivers/scsi/cxlflash/common.h       |  205 ++-
 drivers/scsi/cxlflash/lunmgt.c       |   35 +-
 drivers/scsi/cxlflash/main.c         | 2547 ++++++++++++++++++++++++++--------
 drivers/scsi/cxlflash/main.h         |   10 +-
 drivers/scsi/cxlflash/sislite.h      |  170 ++-
 drivers/scsi/cxlflash/superpipe.c    |  233 ++--
 drivers/scsi/cxlflash/superpipe.h    |   56 +-
 drivers/scsi/cxlflash/vlun.c         |  337 +++--
 drivers/scsi/cxlflash/vlun.h         |    2 +-
 include/uapi/scsi/cxlflash_ioctl.h   |   86 +-
 14 files changed, 2856 insertions(+), 911 deletions(-)

--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 01/44] scsi: cxlflash: Refactor context reset to share reset logic

Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

As staging for supporting hardware with different context reset
registers but a similar reset procedure, refactor the existing context
reset routine to move the reset logic to a common routine. This will
allow hardware with a different reset register to leverage existing
code.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 9c7d1ee5f13a7130f6d3df307ec010e9e003fa98)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/main.c | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index b17ebf6d0a7e..a990efb27197 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -188,10 +188,11 @@ static void cmd_complete(struct afu_cmd *cmd)
 }
 
 /**
- * context_reset_ioarrin() - reset command owner context via IOARRIN register
+ * context_reset() - reset command owner context via specified register
  * @cmd: AFU command that timed out.
+ * @reset_reg: MMIO register to perform reset.
  */
-static void context_reset_ioarrin(struct afu_cmd *cmd)
+static void context_reset(struct afu_cmd *cmd, __be64 __iomem *reset_reg)
 {
  int nretry = 0;
  u64 rrin = 0x1;
@@ -201,9 +202,9 @@ static void context_reset_ioarrin(struct afu_cmd *cmd)
 
  pr_debug("%s: cmd=%p\n", __func__, cmd);
 
- writeq_be(rrin, &afu->host_map->ioarrin);
+ writeq_be(rrin, reset_reg);
  do {
- rrin = readq_be(&afu->host_map->ioarrin);
+ rrin = readq_be(reset_reg);
  if (rrin != 0x1)
  break;
  /* Double delay each time */
@@ -215,6 +216,17 @@ static void context_reset_ioarrin(struct afu_cmd *cmd)
 }
 
 /**
+ * context_reset_ioarrin() - reset command owner context via IOARRIN register
+ * @cmd: AFU command that timed out.
+ */
+static void context_reset_ioarrin(struct afu_cmd *cmd)
+{
+ struct afu *afu = cmd->parent;
+
+ context_reset(cmd, &afu->host_map->ioarrin);
+}
+
+/**
  * send_cmd_ioarrin() - sends an AFU command via IOARRIN register
  * @afu: AFU associated with the host.
  * @cmd: AFU command to send.
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 02/44] scsi: cxlflash: Support SQ Command Mode

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

The SISLite specification outlines a new queuing model to improve
over the MMIO-based IOARRIN model that exists today. This new model
uses a submission queue that exists in host memory and is shared with
the device. Each entry in the queue is an IOARCB that describes a
transfer request. When requests are submitted, IOARCBs ('current'
position tracked in host software) are populated and the submission
queue tail pointer is then updated via MMIO to make the device aware
of the requests.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 696d0b0c715360ce28fedd3c8b009d3771a5ddeb)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/common.h     | 30 +++++++++++-
 drivers/scsi/cxlflash/main.c       | 98 ++++++++++++++++++++++++++++++++++++--
 drivers/scsi/cxlflash/sislite.h    | 19 +++++++-
 drivers/scsi/cxlflash/superpipe.c  | 18 +++++--
 include/uapi/scsi/cxlflash_ioctl.h |  1 +
 5 files changed, 153 insertions(+), 13 deletions(-)

diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h
index 0e9de5d62da2..dee865735ac0 100644
--- a/drivers/scsi/cxlflash/common.h
+++ b/drivers/scsi/cxlflash/common.h
@@ -54,6 +54,9 @@ extern const struct file_operations cxlflash_cxl_fops;
 /* RRQ for master issued cmds */
 #define NUM_RRQ_ENTRY                   CXLFLASH_MAX_CMDS
 
+/* SQ for master issued cmds */
+#define NUM_SQ_ENTRY CXLFLASH_MAX_CMDS
+
 
 static inline void check_sizes(void)
 {
@@ -155,8 +158,8 @@ static inline struct afu_cmd *sc_to_afucz(struct scsi_cmnd *sc)
 
 struct afu {
  /* Stuff requiring alignment go first. */
-
- u64 rrq_entry[NUM_RRQ_ENTRY]; /* 2K RRQ */
+ struct sisl_ioarcb sq[NUM_SQ_ENTRY]; /* 16K SQ */
+ u64 rrq_entry[NUM_RRQ_ENTRY]; /* 2K RRQ */
 
  /* Beware of alignment till here. Preferably introduce new
  * fields after this point
@@ -174,6 +177,12 @@ struct afu {
  struct kref mapcount;
 
  ctx_hndl_t ctx_hndl; /* master's context handle */
+
+ atomic_t hsq_credits;
+ spinlock_t hsq_slock;
+ struct sisl_ioarcb *hsq_start;
+ struct sisl_ioarcb *hsq_end;
+ struct sisl_ioarcb *hsq_curr;
  u64 *hrrq_start;
  u64 *hrrq_end;
  u64 *hrrq_curr;
@@ -191,6 +200,23 @@ struct afu {
 
 };
 
+static inline bool afu_is_cmd_mode(struct afu *afu, u64 cmd_mode)
+{
+ u64 afu_cap = afu->interface_version >> SISL_INTVER_CAP_SHIFT;
+
+ return afu_cap & cmd_mode;
+}
+
+static inline bool afu_is_sq_cmd_mode(struct afu *afu)
+{
+ return afu_is_cmd_mode(afu, SISL_INTVER_CAP_SQ_CMD_MODE);
+}
+
+static inline bool afu_is_ioarrin_cmd_mode(struct afu *afu)
+{
+ return afu_is_cmd_mode(afu, SISL_INTVER_CAP_IOARRIN_CMD_MODE);
+}
+
 static inline u64 lun_to_lunid(u64 lun)
 {
  __be64 lun_id;
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index a990efb27197..d2bac4b7b85f 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -227,6 +227,17 @@ static void context_reset_ioarrin(struct afu_cmd *cmd)
 }
 
 /**
+ * context_reset_sq() - reset command owner context w/ SQ Context Reset register
+ * @cmd: AFU command that timed out.
+ */
+static void context_reset_sq(struct afu_cmd *cmd)
+{
+ struct afu *afu = cmd->parent;
+
+ context_reset(cmd, &afu->host_map->sq_ctx_reset);
+}
+
+/**
  * send_cmd_ioarrin() - sends an AFU command via IOARRIN register
  * @afu: AFU associated with the host.
  * @cmd: AFU command to send.
@@ -269,6 +280,49 @@ static int send_cmd_ioarrin(struct afu *afu, struct afu_cmd *cmd)
 }
 
 /**
+ * send_cmd_sq() - sends an AFU command via SQ ring
+ * @afu: AFU associated with the host.
+ * @cmd: AFU command to send.
+ *
+ * Return:
+ * 0 on success, SCSI_MLQUEUE_HOST_BUSY on failure
+ */
+static int send_cmd_sq(struct afu *afu, struct afu_cmd *cmd)
+{
+ struct cxlflash_cfg *cfg = afu->parent;
+ struct device *dev = &cfg->dev->dev;
+ int rc = 0;
+ int newval;
+ ulong lock_flags;
+
+ newval = atomic_dec_if_positive(&afu->hsq_credits);
+ if (newval <= 0) {
+ rc = SCSI_MLQUEUE_HOST_BUSY;
+ goto out;
+ }
+
+ cmd->rcb.ioasa = &cmd->sa;
+
+ spin_lock_irqsave(&afu->hsq_slock, lock_flags);
+
+ *afu->hsq_curr = cmd->rcb;
+ if (afu->hsq_curr < afu->hsq_end)
+ afu->hsq_curr++;
+ else
+ afu->hsq_curr = afu->hsq_start;
+ writeq_be((u64)afu->hsq_curr, &afu->host_map->sq_tail);
+
+ spin_unlock_irqrestore(&afu->hsq_slock, lock_flags);
+out:
+ dev_dbg(dev, "%s: cmd=%p len=%d ea=%p ioasa=%p rc=%d curr=%p "
+       "head=%016llX tail=%016llX\n", __func__, cmd, cmd->rcb.data_len,
+       (void *)cmd->rcb.data_ea, cmd->rcb.ioasa, rc, afu->hsq_curr,
+       readq_be(&afu->host_map->sq_head),
+       readq_be(&afu->host_map->sq_tail));
+ return rc;
+}
+
+/**
  * wait_resp() - polls for a response or timeout to a sent AFU command
  * @afu: AFU associated with the host.
  * @cmd: AFU command that was sent.
@@ -739,7 +793,7 @@ static int alloc_mem(struct cxlflash_cfg *cfg)
  int rc = 0;
  struct device *dev = &cfg->dev->dev;
 
- /* AFU is ~12k, i.e. only one 64k page or up to four 4k pages */
+ /* AFU is ~28k, i.e. only one 64k page or up to seven 4k pages */
  cfg->afu = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
     get_order(sizeof(struct afu)));
  if (unlikely(!cfg->afu)) {
@@ -1127,6 +1181,8 @@ static irqreturn_t cxlflash_rrq_irq(int irq, void *data)
 {
  struct afu *afu = (struct afu *)data;
  struct afu_cmd *cmd;
+ struct sisl_ioasa *ioasa;
+ struct sisl_ioarcb *ioarcb;
  bool toggle = afu->toggle;
  u64 entry,
     *hrrq_start = afu->hrrq_start,
@@ -1140,7 +1196,16 @@ static irqreturn_t cxlflash_rrq_irq(int irq, void *data)
  if ((entry & SISL_RESP_HANDLE_T_BIT) != toggle)
  break;
 
- cmd = (struct afu_cmd *)(entry & ~SISL_RESP_HANDLE_T_BIT);
+ entry &= ~SISL_RESP_HANDLE_T_BIT;
+
+ if (afu_is_sq_cmd_mode(afu)) {
+ ioasa = (struct sisl_ioasa *)entry;
+ cmd = container_of(ioasa, struct afu_cmd, sa);
+ } else {
+ ioarcb = (struct sisl_ioarcb *)entry;
+ cmd = container_of(ioarcb, struct afu_cmd, rcb);
+ }
+
  cmd_complete(cmd);
 
  /* Advance to next entry or wrap and flip the toggle bit */
@@ -1150,6 +1215,8 @@ static irqreturn_t cxlflash_rrq_irq(int irq, void *data)
  hrrq_curr = hrrq_start;
  toggle ^= SISL_RESP_HANDLE_T_BIT;
  }
+
+ atomic_inc(&afu->hsq_credits);
  }
 
  afu->hrrq_curr = hrrq_curr;
@@ -1402,10 +1469,15 @@ static int init_global(struct cxlflash_cfg *cfg)
 
  pr_debug("%s: wwpn0=0x%llX wwpn1=0x%llX\n", __func__, wwpn[0], wwpn[1]);
 
- /* Set up RRQ in AFU for master issued cmds */
+ /* Set up RRQ and SQ in AFU for master issued cmds */
  writeq_be((u64) afu->hrrq_start, &afu->host_map->rrq_start);
  writeq_be((u64) afu->hrrq_end, &afu->host_map->rrq_end);
 
+ if (afu_is_sq_cmd_mode(afu)) {
+ writeq_be((u64)afu->hsq_start, &afu->host_map->sq_start);
+ writeq_be((u64)afu->hsq_end, &afu->host_map->sq_end);
+ }
+
  /* AFU configuration */
  reg = readq_be(&afu->afu_map->global.regs.afu_config);
  reg |= SISL_AFUCONF_AR_ALL|SISL_AFUCONF_ENDIAN;
@@ -1480,6 +1552,17 @@ static int start_afu(struct cxlflash_cfg *cfg)
  afu->hrrq_curr = afu->hrrq_start;
  afu->toggle = 1;
 
+ /* Initialize SQ */
+ if (afu_is_sq_cmd_mode(afu)) {
+ memset(&afu->sq, 0, sizeof(afu->sq));
+ afu->hsq_start = &afu->sq[0];
+ afu->hsq_end = &afu->sq[NUM_SQ_ENTRY - 1];
+ afu->hsq_curr = afu->hsq_start;
+
+ spin_lock_init(&afu->hsq_slock);
+ atomic_set(&afu->hsq_credits, NUM_SQ_ENTRY - 1);
+ }
+
  rc = init_global(cfg);
 
  pr_debug("%s: returning rc=%d\n", __func__, rc);
@@ -1641,8 +1724,13 @@ static int init_afu(struct cxlflash_cfg *cfg)
  goto err2;
  }
 
- afu->send_cmd = send_cmd_ioarrin;
- afu->context_reset = context_reset_ioarrin;
+ if (afu_is_sq_cmd_mode(afu)) {
+ afu->send_cmd = send_cmd_sq;
+ afu->context_reset = context_reset_sq;
+ } else {
+ afu->send_cmd = send_cmd_ioarrin;
+ afu->context_reset = context_reset_ioarrin;
+ }
 
  pr_debug("%s: afu version %s, interface version 0x%llX\n", __func__,
  afu->version, afu->interface_version);
diff --git a/drivers/scsi/cxlflash/sislite.h b/drivers/scsi/cxlflash/sislite.h
index 1a2d09c148b3..a6e48a893fef 100644
--- a/drivers/scsi/cxlflash/sislite.h
+++ b/drivers/scsi/cxlflash/sislite.h
@@ -72,7 +72,10 @@ struct sisl_ioarcb {
  u16 timeout; /* in units specified by req_flags */
  u32 rsvd1;
  u8 cdb[16]; /* must be in big endian */
- u64 reserved; /* Reserved area */
+ union {
+ u64 reserved; /* Reserved for IOARRIN mode */
+ struct sisl_ioasa *ioasa; /* IOASA EA for SQ Mode */
+ };
 } __packed;
 
 struct sisl_rc {
@@ -260,6 +263,11 @@ struct sisl_host_map {
  __be64 cmd_room;
  __be64 ctx_ctrl; /* least significant byte or b56:63 is LISN# */
  __be64 mbox_w; /* restricted use */
+ __be64 sq_start; /* Submission Queue (R/W): write sequence and */
+ __be64 sq_end; /* inclusion semantics are the same as RRQ    */
+ __be64 sq_head; /* Submission Queue Head (R): for debugging   */
+ __be64 sq_tail; /* Submission Queue TAIL (R/W): next IOARCB   */
+ __be64 sq_ctx_reset; /* Submission Queue Context Reset (R/W)      */
 };
 
 /* per context provisioning & control MMIO */
@@ -348,6 +356,15 @@ struct sisl_global_regs {
  __be64 rsvd[0xf8];
  __le64 afu_version;
  __be64 interface_version;
+#define SISL_INTVER_CAP_SHIFT 16
+#define SISL_INTVER_MAJ_SHIFT 8
+#define SISL_INTVER_CAP_MASK 0xFFFFFFFF00000000ULL
+#define SISL_INTVER_MAJ_MASK 0x00000000FFFF0000ULL
+#define SISL_INTVER_MIN_MASK 0x000000000000FFFFULL
+#define SISL_INTVER_CAP_IOARRIN_CMD_MODE 0x800000000000ULL
+#define SISL_INTVER_CAP_SQ_CMD_MODE 0x400000000000ULL
+#define SISL_INTVER_CAP_RESERVED_CMD_MODE_A 0x200000000000ULL
+#define SISL_INTVER_CAP_RESERVED_CMD_MODE_B 0x100000000000ULL
 };
 
 #define CXLFLASH_NUM_FC_PORTS   2
diff --git a/drivers/scsi/cxlflash/superpipe.c b/drivers/scsi/cxlflash/superpipe.c
index 9636970d9611..42674ae6f4dd 100644
--- a/drivers/scsi/cxlflash/superpipe.c
+++ b/drivers/scsi/cxlflash/superpipe.c
@@ -1287,6 +1287,7 @@ static int cxlflash_disk_attach(struct scsi_device *sdev,
  int rc = 0;
  u32 perms;
  int ctxid = -1;
+ u64 flags = 0UL;
  u64 rctxid = 0UL;
  struct file *file = NULL;
 
@@ -1426,10 +1427,11 @@ static int cxlflash_disk_attach(struct scsi_device *sdev,
 
 out_attach:
  if (fd != -1)
- attach->hdr.return_flags = DK_CXLFLASH_APP_CLOSE_ADAP_FD;
- else
- attach->hdr.return_flags = 0;
+ flags |= DK_CXLFLASH_APP_CLOSE_ADAP_FD;
+ if (afu_is_sq_cmd_mode(afu))
+ flags |= DK_CXLFLASH_CONTEXT_SQ_CMD_MODE;
 
+ attach->hdr.return_flags = flags;
  attach->context_id = ctxi->ctxid;
  attach->block_size = gli->blk_len;
  attach->mmio_size = sizeof(afu->afu_map->hosts[0].harea);
@@ -1617,6 +1619,7 @@ static int cxlflash_afu_recover(struct scsi_device *sdev,
  struct afu *afu = cfg->afu;
  struct ctx_info *ctxi = NULL;
  struct mutex *mutex = &cfg->ctx_recovery_mutex;
+ u64 flags;
  u64 ctxid = DECODE_CTXID(recover->context_id),
     rctxid = recover->context_id;
  long reg;
@@ -1672,11 +1675,16 @@ static int cxlflash_afu_recover(struct scsi_device *sdev,
  }
 
  ctxi->err_recovery_active = false;
+
+ flags = DK_CXLFLASH_APP_CLOSE_ADAP_FD |
+ DK_CXLFLASH_RECOVER_AFU_CONTEXT_RESET;
+ if (afu_is_sq_cmd_mode(afu))
+ flags |= DK_CXLFLASH_CONTEXT_SQ_CMD_MODE;
+
+ recover->hdr.return_flags = flags;
  recover->context_id = ctxi->ctxid;
  recover->adap_fd = new_adap_fd;
  recover->mmio_size = sizeof(afu->afu_map->hosts[0].harea);
- recover->hdr.return_flags = DK_CXLFLASH_APP_CLOSE_ADAP_FD |
- DK_CXLFLASH_RECOVER_AFU_CONTEXT_RESET;
  goto out;
  }
 
diff --git a/include/uapi/scsi/cxlflash_ioctl.h b/include/uapi/scsi/cxlflash_ioctl.h
index 6bf1f8a022b1..e9fdc12ad984 100644
--- a/include/uapi/scsi/cxlflash_ioctl.h
+++ b/include/uapi/scsi/cxlflash_ioctl.h
@@ -40,6 +40,7 @@ struct dk_cxlflash_hdr {
  */
 #define DK_CXLFLASH_ALL_PORTS_ACTIVE 0x0000000000000001ULL
 #define DK_CXLFLASH_APP_CLOSE_ADAP_FD 0x0000000000000002ULL
+#define DK_CXLFLASH_CONTEXT_SQ_CMD_MODE 0x0000000000000004ULL
 
 /*
  * General Notes:
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 03/44] scsi: cxlflash: Cleanup prints

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

The usage of prints within the cxlflash driver is inconsistent. This
hinders debug and makes the driver source and log output appear sloppy.

The following cleanups help unify the prints within cxlflash:
 - move all prints to dev-* where possible
 - transition all hex prints to lowercase
 - standardize variable prints in debug output
 - derive pointers in a consistent manner
 - change int to bool where appropriate
 - remove superfluous data from prints and print statements that do not
   make sense

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Reviewed-by: Andrew Donnellan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit fb67d44dfbdf85d984b9b40284e90636a3a7b21d)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/lunmgt.c    |  31 ++--
 drivers/scsi/cxlflash/main.c      | 319 ++++++++++++++++++--------------------
 drivers/scsi/cxlflash/superpipe.c | 165 ++++++++++----------
 drivers/scsi/cxlflash/vlun.c      | 169 ++++++++++----------
 4 files changed, 346 insertions(+), 338 deletions(-)

diff --git a/drivers/scsi/cxlflash/lunmgt.c b/drivers/scsi/cxlflash/lunmgt.c
index 6c318db90c85..0efed177cc8b 100644
--- a/drivers/scsi/cxlflash/lunmgt.c
+++ b/drivers/scsi/cxlflash/lunmgt.c
@@ -32,11 +32,13 @@
  */
 static struct llun_info *create_local(struct scsi_device *sdev, u8 *wwid)
 {
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
+ struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = NULL;
 
  lli = kzalloc(sizeof(*lli), GFP_KERNEL);
  if (unlikely(!lli)) {
- pr_err("%s: could not allocate lli\n", __func__);
+ dev_err(dev, "%s: could not allocate lli\n", __func__);
  goto out;
  }
 
@@ -58,11 +60,13 @@ static struct llun_info *create_local(struct scsi_device *sdev, u8 *wwid)
  */
 static struct glun_info *create_global(struct scsi_device *sdev, u8 *wwid)
 {
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
+ struct device *dev = &cfg->dev->dev;
  struct glun_info *gli = NULL;
 
  gli = kzalloc(sizeof(*gli), GFP_KERNEL);
  if (unlikely(!gli)) {
- pr_err("%s: could not allocate gli\n", __func__);
+ dev_err(dev, "%s: could not allocate gli\n", __func__);
  goto out;
  }
 
@@ -129,10 +133,10 @@ static struct glun_info *lookup_global(u8 *wwid)
  */
 static struct llun_info *find_and_create_lun(struct scsi_device *sdev, u8 *wwid)
 {
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
+ struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = NULL;
  struct glun_info *gli = NULL;
- struct Scsi_Host *shost = sdev->host;
- struct cxlflash_cfg *cfg = shost_priv(shost);
 
  if (unlikely(!wwid))
  goto out;
@@ -165,7 +169,7 @@ static struct llun_info *find_and_create_lun(struct scsi_device *sdev, u8 *wwid)
  list_add(&gli->list, &global.gluns);
 
 out:
- pr_debug("%s: returning %p\n", __func__, lli);
+ dev_dbg(dev, "%s: returning lli=%p, gli=%p\n", __func__, lli, gli);
  return lli;
 }
 
@@ -225,17 +229,18 @@ void cxlflash_term_global_luns(void)
 int cxlflash_manage_lun(struct scsi_device *sdev,
  struct dk_cxlflash_manage_lun *manage)
 {
- int rc = 0;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
+ struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = NULL;
+ int rc = 0;
  u64 flags = manage->hdr.flags;
  u32 chan = sdev->channel;
 
  mutex_lock(&global.mutex);
  lli = find_and_create_lun(sdev, manage->wwid);
- pr_debug("%s: ENTER: WWID = %016llX%016llX, flags = %016llX li = %p\n",
- __func__, get_unaligned_be64(&manage->wwid[0]),
- get_unaligned_be64(&manage->wwid[8]),
- manage->hdr.flags, lli);
+ dev_dbg(dev, "%s: WWID=%016llx%016llx, flags=%016llx lli=%p\n",
+ __func__, get_unaligned_be64(&manage->wwid[0]),
+ get_unaligned_be64(&manage->wwid[8]), manage->hdr.flags, lli);
  if (unlikely(!lli)) {
  rc = -ENOMEM;
  goto out;
@@ -265,11 +270,11 @@ int cxlflash_manage_lun(struct scsi_device *sdev,
  }
  }
 
- pr_debug("%s: port_sel = %08X chan = %u lun_id = %016llX\n", __func__,
- lli->port_sel, chan, lli->lun_id[chan]);
+ dev_dbg(dev, "%s: port_sel=%08x chan=%u lun_id=%016llx\n",
+ __func__, lli->port_sel, chan, lli->lun_id[chan]);
 
 out:
  mutex_unlock(&global.mutex);
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index d2bac4b7b85f..ab38bca5df2b 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -43,6 +43,9 @@ MODULE_LICENSE("GPL");
  */
 static void process_cmd_err(struct afu_cmd *cmd, struct scsi_cmnd *scp)
 {
+ struct afu *afu = cmd->parent;
+ struct cxlflash_cfg *cfg = afu->parent;
+ struct device *dev = &cfg->dev->dev;
  struct sisl_ioarcb *ioarcb;
  struct sisl_ioasa *ioasa;
  u32 resid;
@@ -56,21 +59,20 @@ static void process_cmd_err(struct afu_cmd *cmd, struct scsi_cmnd *scp)
  if (ioasa->rc.flags & SISL_RC_FLAGS_UNDERRUN) {
  resid = ioasa->resid;
  scsi_set_resid(scp, resid);
- pr_debug("%s: cmd underrun cmd = %p scp = %p, resid = %d\n",
- __func__, cmd, scp, resid);
+ dev_dbg(dev, "%s: cmd underrun cmd = %p scp = %p, resid = %d\n",
+ __func__, cmd, scp, resid);
  }
 
  if (ioasa->rc.flags & SISL_RC_FLAGS_OVERRUN) {
- pr_debug("%s: cmd underrun cmd = %p scp = %p\n",
- __func__, cmd, scp);
+ dev_dbg(dev, "%s: cmd underrun cmd = %p scp = %p\n",
+ __func__, cmd, scp);
  scp->result = (DID_ERROR << 16);
  }
 
- pr_debug("%s: cmd failed afu_rc=%d scsi_rc=%d fc_rc=%d "
- "afu_extra=0x%X, scsi_extra=0x%X, fc_extra=0x%X\n",
- __func__, ioasa->rc.afu_rc, ioasa->rc.scsi_rc,
- ioasa->rc.fc_rc, ioasa->afu_extra, ioasa->scsi_extra,
- ioasa->fc_extra);
+ dev_dbg(dev, "%s: cmd failed afu_rc=%02x scsi_rc=%02x fc_rc=%02x "
+ "afu_extra=%02x scsi_extra=%02x fc_extra=%02x\n", __func__,
+ ioasa->rc.afu_rc, ioasa->rc.scsi_rc, ioasa->rc.fc_rc,
+ ioasa->afu_extra, ioasa->scsi_extra, ioasa->fc_extra);
 
  if (ioasa->rc.scsi_rc) {
  /* We have a SCSI status */
@@ -159,6 +161,7 @@ static void cmd_complete(struct afu_cmd *cmd)
  ulong lock_flags;
  struct afu *afu = cmd->parent;
  struct cxlflash_cfg *cfg = afu->parent;
+ struct device *dev = &cfg->dev->dev;
  bool cmd_is_tmf;
 
  if (cmd->scp) {
@@ -170,9 +173,8 @@ static void cmd_complete(struct afu_cmd *cmd)
 
  cmd_is_tmf = cmd->cmd_tmf;
 
- pr_debug_ratelimited("%s: calling scsi_done scp=%p result=%X "
-     "ioasc=%d\n", __func__, scp, scp->result,
-     cmd->sa.ioasc);
+ dev_dbg_ratelimited(dev, "%s:scp=%p result=%08x ioasc=%08x\n",
+    __func__, scp, scp->result, cmd->sa.ioasc);
 
  scsi_dma_unmap(scp);
  scp->scsi_done(scp);
@@ -200,7 +202,7 @@ static void context_reset(struct afu_cmd *cmd, __be64 __iomem *reset_reg)
  struct cxlflash_cfg *cfg = afu->parent;
  struct device *dev = &cfg->dev->dev;
 
- pr_debug("%s: cmd=%p\n", __func__, cmd);
+ dev_dbg(dev, "%s: cmd=%p\n", __func__, cmd);
 
  writeq_be(rrin, reset_reg);
  do {
@@ -211,7 +213,7 @@ static void context_reset(struct afu_cmd *cmd, __be64 __iomem *reset_reg)
  udelay(1 << nretry);
  } while (nretry++ < MC_ROOM_RETRY_CNT);
 
- dev_dbg(dev, "%s: returning rrin=0x%016llX nretry=%d\n",
+ dev_dbg(dev, "%s: returning rrin=%016llx nretry=%d\n",
  __func__, rrin, nretry);
 }
 
@@ -274,8 +276,8 @@ static int send_cmd_ioarrin(struct afu *afu, struct afu_cmd *cmd)
  writeq_be((u64)&cmd->rcb, &afu->host_map->ioarrin);
 out:
  spin_unlock_irqrestore(&afu->rrin_slock, lock_flags);
- pr_devel("%s: cmd=%p len=%d ea=%p rc=%d\n", __func__, cmd,
- cmd->rcb.data_len, (void *)cmd->rcb.data_ea, rc);
+ dev_dbg(dev, "%s: cmd=%p len=%u ea=%016llx rc=%d\n", __func__,
+ cmd, cmd->rcb.data_len, cmd->rcb.data_ea, rc);
  return rc;
 }
 
@@ -314,9 +316,9 @@ static int send_cmd_sq(struct afu *afu, struct afu_cmd *cmd)
 
  spin_unlock_irqrestore(&afu->hsq_slock, lock_flags);
 out:
- dev_dbg(dev, "%s: cmd=%p len=%d ea=%p ioasa=%p rc=%d curr=%p "
-       "head=%016llX tail=%016llX\n", __func__, cmd, cmd->rcb.data_len,
-       (void *)cmd->rcb.data_ea, cmd->rcb.ioasa, rc, afu->hsq_curr,
+ dev_dbg(dev, "%s: cmd=%p len=%u ea=%016llx ioasa=%p rc=%d curr=%p "
+       "head=%016llx tail=%016llx\n", __func__, cmd, cmd->rcb.data_len,
+       cmd->rcb.data_ea, cmd->rcb.ioasa, rc, afu->hsq_curr,
        readq_be(&afu->host_map->sq_head),
        readq_be(&afu->host_map->sq_tail));
  return rc;
@@ -332,6 +334,8 @@ static int send_cmd_sq(struct afu *afu, struct afu_cmd *cmd)
  */
 static int wait_resp(struct afu *afu, struct afu_cmd *cmd)
 {
+ struct cxlflash_cfg *cfg = afu->parent;
+ struct device *dev = &cfg->dev->dev;
  int rc = 0;
  ulong timeout = msecs_to_jiffies(cmd->rcb.timeout * 2 * 1000);
 
@@ -342,10 +346,8 @@ static int wait_resp(struct afu *afu, struct afu_cmd *cmd)
  }
 
  if (unlikely(cmd->sa.ioasc != 0)) {
- pr_err("%s: CMD 0x%X failed, IOASC: flags 0x%X, afu_rc 0x%X, "
-       "scsi_rc 0x%X, fc_rc 0x%X\n", __func__, cmd->rcb.cdb[0],
-       cmd->sa.rc.flags, cmd->sa.rc.afu_rc, cmd->sa.rc.scsi_rc,
-       cmd->sa.rc.fc_rc);
+ dev_err(dev, "%s: cmd %02x failed, ioasc=%08x\n",
+ __func__, cmd->rcb.cdb[0], cmd->sa.ioasc);
  rc = -1;
  }
 
@@ -364,8 +366,7 @@ static int wait_resp(struct afu *afu, struct afu_cmd *cmd)
 static int send_tmf(struct afu *afu, struct scsi_cmnd *scp, u64 tmfcmd)
 {
  u32 port_sel = scp->device->channel + 1;
- struct Scsi_Host *host = scp->device->host;
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(scp->device->host);
  struct afu_cmd *cmd = sc_to_afucz(scp);
  struct device *dev = &cfg->dev->dev;
  ulong lock_flags;
@@ -410,7 +411,7 @@ static int send_tmf(struct afu *afu, struct scsi_cmnd *scp, u64 tmfcmd)
        to);
  if (!to) {
  cfg->tmf_active = false;
- dev_err(dev, "%s: TMF timed out!\n", __func__);
+ dev_err(dev, "%s: TMF timed out\n", __func__);
  rc = -1;
  }
  spin_unlock_irqrestore(&cfg->tmf_slock, lock_flags);
@@ -448,7 +449,7 @@ static const char *cxlflash_driver_info(struct Scsi_Host *host)
  */
 static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(host);
  struct afu *afu = cfg->afu;
  struct device *dev = &cfg->dev->dev;
  struct afu_cmd *cmd = sc_to_afucz(scp);
@@ -461,7 +462,7 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
  int kref_got = 0;
 
  dev_dbg_ratelimited(dev, "%s: (scp=%p) %d/%d/%d/%llu "
-    "cdb=(%08X-%08X-%08X-%08X)\n",
+    "cdb=(%08x-%08x-%08x-%08x)\n",
     __func__, scp, host->host_no, scp->device->channel,
     scp->device->id, scp->device->lun,
     get_unaligned_be32(&((u32 *)scp->cmnd)[0]),
@@ -483,11 +484,11 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
 
  switch (cfg->state) {
  case STATE_RESET:
- dev_dbg_ratelimited(dev, "%s: device is in reset!\n", __func__);
+ dev_dbg_ratelimited(dev, "%s: device is in reset\n", __func__);
  rc = SCSI_MLQUEUE_HOST_BUSY;
  goto out;
  case STATE_FAILTERM:
- dev_dbg_ratelimited(dev, "%s: device has failed!\n", __func__);
+ dev_dbg_ratelimited(dev, "%s: device has failed\n", __func__);
  scp->result = (DID_NO_CONNECT << 16);
  scp->scsi_done(scp);
  rc = 0;
@@ -502,7 +503,7 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
  if (likely(sg)) {
  nseg = scsi_dma_map(scp);
  if (unlikely(nseg < 0)) {
- dev_err(dev, "%s: Fail DMA map!\n", __func__);
+ dev_err(dev, "%s: Fail DMA map\n", __func__);
  rc = SCSI_MLQUEUE_HOST_BUSY;
  goto out;
  }
@@ -531,7 +532,6 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
 out:
  if (kref_got)
  kref_put(&afu->mapcount, afu_unmap);
- pr_devel("%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -651,6 +651,8 @@ static void term_mc(struct cxlflash_cfg *cfg)
  */
 static void term_afu(struct cxlflash_cfg *cfg)
 {
+ struct device *dev = &cfg->dev->dev;
+
  /*
  * Tear down is carefully orchestrated to ensure
  * no interrupts can come in when the problem state
@@ -666,7 +668,7 @@ static void term_afu(struct cxlflash_cfg *cfg)
 
  term_mc(cfg);
 
- pr_debug("%s: returning\n", __func__);
+ dev_dbg(dev, "%s: returning\n", __func__);
 }
 
 /**
@@ -693,8 +695,7 @@ static void notify_shutdown(struct cxlflash_cfg *cfg, bool wait)
  return;
 
  if (!afu || !afu->afu_map) {
- dev_dbg(dev, "%s: The problem state area is not mapped\n",
- __func__);
+ dev_dbg(dev, "%s: Problem state area not mapped\n", __func__);
  return;
  }
 
@@ -736,10 +737,11 @@ static void notify_shutdown(struct cxlflash_cfg *cfg, bool wait)
 static void cxlflash_remove(struct pci_dev *pdev)
 {
  struct cxlflash_cfg *cfg = pci_get_drvdata(pdev);
+ struct device *dev = &pdev->dev;
  ulong lock_flags;
 
  if (!pci_is_enabled(pdev)) {
- pr_debug("%s: Device is disabled\n", __func__);
+ dev_dbg(dev, "%s: Device is disabled\n", __func__);
  return;
  }
 
@@ -775,7 +777,7 @@ static void cxlflash_remove(struct pci_dev *pdev)
  break;
  }
 
- pr_debug("%s: returning\n", __func__);
+ dev_dbg(dev, "%s: returning\n", __func__);
 }
 
 /**
@@ -817,6 +819,7 @@ static int alloc_mem(struct cxlflash_cfg *cfg)
 static int init_pci(struct cxlflash_cfg *cfg)
 {
  struct pci_dev *pdev = cfg->dev;
+ struct device *dev = &cfg->dev->dev;
  int rc = 0;
 
  rc = pci_enable_device(pdev);
@@ -827,15 +830,14 @@ static int init_pci(struct cxlflash_cfg *cfg)
  }
 
  if (rc) {
- dev_err(&pdev->dev, "%s: Cannot enable adapter\n",
- __func__);
+ dev_err(dev, "%s: Cannot enable adapter\n", __func__);
  cxlflash_wait_for_pci_err_recovery(cfg);
  goto out;
  }
  }
 
 out:
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -848,19 +850,19 @@ static int init_pci(struct cxlflash_cfg *cfg)
 static int init_scsi(struct cxlflash_cfg *cfg)
 {
  struct pci_dev *pdev = cfg->dev;
+ struct device *dev = &cfg->dev->dev;
  int rc = 0;
 
  rc = scsi_add_host(cfg->host, &pdev->dev);
  if (rc) {
- dev_err(&pdev->dev, "%s: scsi_add_host failed (rc=%d)\n",
- __func__, rc);
+ dev_err(dev, "%s: scsi_add_host failed rc=%d\n", __func__, rc);
  goto out;
  }
 
  scsi_scan_host(cfg->host);
 
 out:
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -910,16 +912,12 @@ static void set_port_offline(__be64 __iomem *fc_regs)
  * Return:
  * TRUE (1) when the specified port is online
  * FALSE (0) when the specified port fails to come online after timeout
- * -EINVAL when @delay_us is less than 1000
  */
-static int wait_port_online(__be64 __iomem *fc_regs, u32 delay_us, u32 nretry)
+static bool wait_port_online(__be64 __iomem *fc_regs, u32 delay_us, u32 nretry)
 {
  u64 status;
 
- if (delay_us < 1000) {
- pr_err("%s: invalid delay specified %d\n", __func__, delay_us);
- return -EINVAL;
- }
+ WARN_ON(delay_us < 1000);
 
  do {
  msleep(delay_us / 1000);
@@ -943,16 +941,12 @@ static int wait_port_online(__be64 __iomem *fc_regs, u32 delay_us, u32 nretry)
  * Return:
  * TRUE (1) when the specified port is offline
  * FALSE (0) when the specified port fails to go offline after timeout
- * -EINVAL when @delay_us is less than 1000
  */
-static int wait_port_offline(__be64 __iomem *fc_regs, u32 delay_us, u32 nretry)
+static bool wait_port_offline(__be64 __iomem *fc_regs, u32 delay_us, u32 nretry)
 {
  u64 status;
 
- if (delay_us < 1000) {
- pr_err("%s: invalid delay specified %d\n", __func__, delay_us);
- return -EINVAL;
- }
+ WARN_ON(delay_us < 1000);
 
  do {
  msleep(delay_us / 1000);
@@ -981,11 +975,14 @@ static int wait_port_offline(__be64 __iomem *fc_regs, u32 delay_us, u32 nretry)
 static void afu_set_wwpn(struct afu *afu, int port, __be64 __iomem *fc_regs,
  u64 wwpn)
 {
+ struct cxlflash_cfg *cfg = afu->parent;
+ struct device *dev = &cfg->dev->dev;
+
  set_port_offline(fc_regs);
  if (!wait_port_offline(fc_regs, FC_PORT_STATUS_RETRY_INTERVAL_US,
        FC_PORT_STATUS_RETRY_CNT)) {
- pr_debug("%s: wait on port %d to go offline timed out\n",
- __func__, port);
+ dev_dbg(dev, "%s: wait on port %d to go offline timed out\n",
+ __func__, port);
  }
 
  writeq_be(wwpn, &fc_regs[FC_PNAME / 8]);
@@ -993,8 +990,8 @@ static void afu_set_wwpn(struct afu *afu, int port, __be64 __iomem *fc_regs,
  set_port_online(fc_regs);
  if (!wait_port_online(fc_regs, FC_PORT_STATUS_RETRY_INTERVAL_US,
       FC_PORT_STATUS_RETRY_CNT)) {
- pr_debug("%s: wait on port %d to go online timed out\n",
- __func__, port);
+ dev_dbg(dev, "%s: wait on port %d to go online timed out\n",
+ __func__, port);
  }
 }
 
@@ -1013,6 +1010,8 @@ static void afu_set_wwpn(struct afu *afu, int port, __be64 __iomem *fc_regs,
  */
 static void afu_link_reset(struct afu *afu, int port, __be64 __iomem *fc_regs)
 {
+ struct cxlflash_cfg *cfg = afu->parent;
+ struct device *dev = &cfg->dev->dev;
  u64 port_sel;
 
  /* first switch the AFU to the other links, if any */
@@ -1024,21 +1023,21 @@ static void afu_link_reset(struct afu *afu, int port, __be64 __iomem *fc_regs)
  set_port_offline(fc_regs);
  if (!wait_port_offline(fc_regs, FC_PORT_STATUS_RETRY_INTERVAL_US,
        FC_PORT_STATUS_RETRY_CNT))
- pr_err("%s: wait on port %d to go offline timed out\n",
-       __func__, port);
+ dev_err(dev, "%s: wait on port %d to go offline timed out\n",
+ __func__, port);
 
  set_port_online(fc_regs);
  if (!wait_port_online(fc_regs, FC_PORT_STATUS_RETRY_INTERVAL_US,
       FC_PORT_STATUS_RETRY_CNT))
- pr_err("%s: wait on port %d to go online timed out\n",
-       __func__, port);
+ dev_err(dev, "%s: wait on port %d to go online timed out\n",
+ __func__, port);
 
  /* switch back to include this port */
  port_sel |= (1ULL << port);
  writeq_be(port_sel, &afu->afu_map->global.regs.afu_port_sel);
  cxlflash_afu_sync(afu, 0, 0, AFU_GSYNC);
 
- pr_debug("%s: returning port_sel=%lld\n", __func__, port_sel);
+ dev_dbg(dev, "%s: returning port_sel=%016llx\n", __func__, port_sel);
 }
 
 /*
@@ -1148,6 +1147,8 @@ static void afu_err_intr_init(struct afu *afu)
 static irqreturn_t cxlflash_sync_err_irq(int irq, void *data)
 {
  struct afu *afu = (struct afu *)data;
+ struct cxlflash_cfg *cfg = afu->parent;
+ struct device *dev = &cfg->dev->dev;
  u64 reg;
  u64 reg_unmasked;
 
@@ -1155,18 +1156,17 @@ static irqreturn_t cxlflash_sync_err_irq(int irq, void *data)
  reg_unmasked = (reg & SISL_ISTATUS_UNMASK);
 
  if (reg_unmasked == 0UL) {
- pr_err("%s: %llX: spurious interrupt, intr_status %016llX\n",
-       __func__, (u64)afu, reg);
+ dev_err(dev, "%s: spurious interrupt, intr_status=%016llx\n",
+ __func__, reg);
  goto cxlflash_sync_err_irq_exit;
  }
 
- pr_err("%s: %llX: unexpected interrupt, intr_status %016llX\n",
-       __func__, (u64)afu, reg);
+ dev_err(dev, "%s: unexpected interrupt, intr_status=%016llx\n",
+ __func__, reg);
 
  writeq_be(reg_unmasked, &afu->host_map->intr_clear);
 
 cxlflash_sync_err_irq_exit:
- pr_debug("%s: returning rc=%d\n", __func__, IRQ_HANDLED);
  return IRQ_HANDLED;
 }
 
@@ -1248,7 +1248,7 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
  reg_unmasked = (reg & SISL_ASTATUS_UNMASK);
 
  if (reg_unmasked == 0) {
- dev_err(dev, "%s: spurious interrupt, aintr_status 0x%016llX\n",
+ dev_err(dev, "%s: spurious interrupt, aintr_status=%016llx\n",
  __func__, reg);
  goto out;
  }
@@ -1264,7 +1264,7 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
 
  port = info->port;
 
- dev_err(dev, "%s: FC Port %d -> %s, fc_status 0x%08llX\n",
+ dev_err(dev, "%s: FC Port %d -> %s, fc_status=%016llx\n",
  __func__, port, info->desc,
        readq_be(&global->fc_regs[port][FC_STATUS / 8]));
 
@@ -1289,7 +1289,7 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
  * should be the same and tracing one is sufficient.
  */
 
- dev_err(dev, "%s: fc %d: clearing fc_error 0x%08llX\n",
+ dev_err(dev, "%s: fc %d: clearing fc_error=%016llx\n",
  __func__, port, reg);
 
  writeq_be(reg, &global->fc_regs[port][FC_ERROR / 8]);
@@ -1304,7 +1304,6 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
  }
 
 out:
- dev_dbg(dev, "%s: returning IRQ_HANDLED, afu=%p\n", __func__, afu);
  return IRQ_HANDLED;
 }
 
@@ -1316,13 +1315,14 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
  */
 static int start_context(struct cxlflash_cfg *cfg)
 {
+ struct device *dev = &cfg->dev->dev;
  int rc = 0;
 
  rc = cxl_start_context(cfg->mcctx,
        cfg->afu->work.work_element_descriptor,
        NULL);
 
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -1335,7 +1335,8 @@ static int start_context(struct cxlflash_cfg *cfg)
  */
 static int read_vpd(struct cxlflash_cfg *cfg, u64 wwpn[])
 {
- struct pci_dev *dev = cfg->dev;
+ struct device *dev = &cfg->dev->dev;
+ struct pci_dev *pdev = cfg->dev;
  int rc = 0;
  int ro_start, ro_size, i, j, k;
  ssize_t vpd_size;
@@ -1344,10 +1345,10 @@ static int read_vpd(struct cxlflash_cfg *cfg, u64 wwpn[])
  char *wwpn_vpd_tags[NUM_FC_PORTS] = { "V5", "V6" };
 
  /* Get the VPD data from the device */
- vpd_size = cxl_read_adapter_vpd(dev, vpd_data, sizeof(vpd_data));
+ vpd_size = cxl_read_adapter_vpd(pdev, vpd_data, sizeof(vpd_data));
  if (unlikely(vpd_size <= 0)) {
- dev_err(&dev->dev, "%s: Unable to read VPD (size = %ld)\n",
-       __func__, vpd_size);
+ dev_err(dev, "%s: Unable to read VPD (size = %ld)\n",
+ __func__, vpd_size);
  rc = -ENODEV;
  goto out;
  }
@@ -1356,8 +1357,7 @@ static int read_vpd(struct cxlflash_cfg *cfg, u64 wwpn[])
  ro_start = pci_vpd_find_tag(vpd_data, 0, vpd_size,
     PCI_VPD_LRDT_RO_DATA);
  if (unlikely(ro_start < 0)) {
- dev_err(&dev->dev, "%s: VPD Read-only data not found\n",
- __func__);
+ dev_err(dev, "%s: VPD Read-only data not found\n", __func__);
  rc = -ENODEV;
  goto out;
  }
@@ -1367,8 +1367,8 @@ static int read_vpd(struct cxlflash_cfg *cfg, u64 wwpn[])
  j = ro_size;
  i = ro_start + PCI_VPD_LRDT_TAG_SIZE;
  if (unlikely((i + j) > vpd_size)) {
- pr_debug("%s: Might need to read more VPD (%d > %ld)\n",
- __func__, (i + j), vpd_size);
+ dev_dbg(dev, "%s: Might need to read more VPD (%d > %ld)\n",
+ __func__, (i + j), vpd_size);
  ro_size = vpd_size - i;
  }
 
@@ -1386,8 +1386,8 @@ static int read_vpd(struct cxlflash_cfg *cfg, u64 wwpn[])
 
  i = pci_vpd_find_info_keyword(vpd_data, i, j, wwpn_vpd_tags[k]);
  if (unlikely(i < 0)) {
- dev_err(&dev->dev, "%s: Port %d WWPN not found "
- "in VPD\n", __func__, k);
+ dev_err(dev, "%s: Port %d WWPN not found in VPD\n",
+ __func__, k);
  rc = -ENODEV;
  goto out;
  }
@@ -1395,9 +1395,8 @@ static int read_vpd(struct cxlflash_cfg *cfg, u64 wwpn[])
  j = pci_vpd_info_field_size(&vpd_data[i]);
  i += PCI_VPD_INFO_FLD_HDR_SIZE;
  if (unlikely((i + j > vpd_size) || (j != WWPN_LEN))) {
- dev_err(&dev->dev, "%s: Port %d WWPN incomplete or "
- "VPD corrupt\n",
-       __func__, k);
+ dev_err(dev, "%s: Port %d WWPN incomplete or bad VPD\n",
+ __func__, k);
  rc = -ENODEV;
  goto out;
  }
@@ -1405,15 +1404,15 @@ static int read_vpd(struct cxlflash_cfg *cfg, u64 wwpn[])
  memcpy(tmp_buf, &vpd_data[i], WWPN_LEN);
  rc = kstrtoul(tmp_buf, WWPN_LEN, (ulong *)&wwpn[k]);
  if (unlikely(rc)) {
- dev_err(&dev->dev, "%s: Fail to convert port %d WWPN "
- "to integer\n", __func__, k);
+ dev_err(dev, "%s: WWPN conversion failed for port %d\n",
+ __func__, k);
  rc = -ENODEV;
  goto out;
  }
  }
 
 out:
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -1467,7 +1466,8 @@ static int init_global(struct cxlflash_cfg *cfg)
  goto out;
  }
 
- pr_debug("%s: wwpn0=0x%llX wwpn1=0x%llX\n", __func__, wwpn[0], wwpn[1]);
+ dev_dbg(dev, "%s: wwpn0=%016llx wwpn1=%016llx\n",
+ __func__, wwpn[0], wwpn[1]);
 
  /* Set up RRQ and SQ in AFU for master issued cmds */
  writeq_be((u64) afu->hrrq_start, &afu->host_map->rrq_start);
@@ -1527,7 +1527,6 @@ static int init_global(struct cxlflash_cfg *cfg)
   &afu->ctrl_map->ctx_cap);
  /* Initialize heartbeat */
  afu->hb = readq_be(&afu->afu_map->global.regs.afu_hb);
-
 out:
  return rc;
 }
@@ -1539,6 +1538,7 @@ static int init_global(struct cxlflash_cfg *cfg)
 static int start_afu(struct cxlflash_cfg *cfg)
 {
  struct afu *afu = cfg->afu;
+ struct device *dev = &cfg->dev->dev;
  int rc = 0;
 
  init_pcr(cfg);
@@ -1565,7 +1565,7 @@ static int start_afu(struct cxlflash_cfg *cfg)
 
  rc = init_global(cfg);
 
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -1585,7 +1585,7 @@ static enum undo_level init_intr(struct cxlflash_cfg *cfg,
 
  rc = cxl_allocate_afu_irqs(ctx, 3);
  if (unlikely(rc)) {
- dev_err(dev, "%s: call to allocate_afu_irqs failed rc=%d!\n",
+ dev_err(dev, "%s: allocate_afu_irqs failed rc=%d\n",
  __func__, rc);
  level = UNDO_NOOP;
  goto out;
@@ -1594,8 +1594,7 @@ static enum undo_level init_intr(struct cxlflash_cfg *cfg,
  rc = cxl_map_afu_irq(ctx, 1, cxlflash_sync_err_irq, afu,
      "SISL_MSI_SYNC_ERROR");
  if (unlikely(rc <= 0)) {
- dev_err(dev, "%s: IRQ 1 (SISL_MSI_SYNC_ERROR) map failed!\n",
- __func__);
+ dev_err(dev, "%s: SISL_MSI_SYNC_ERROR map failed\n", __func__);
  level = FREE_IRQ;
  goto out;
  }
@@ -1603,8 +1602,7 @@ static enum undo_level init_intr(struct cxlflash_cfg *cfg,
  rc = cxl_map_afu_irq(ctx, 2, cxlflash_rrq_irq, afu,
      "SISL_MSI_RRQ_UPDATED");
  if (unlikely(rc <= 0)) {
- dev_err(dev, "%s: IRQ 2 (SISL_MSI_RRQ_UPDATED) map failed!\n",
- __func__);
+ dev_err(dev, "%s: SISL_MSI_RRQ_UPDATED map failed\n", __func__);
  level = UNMAP_ONE;
  goto out;
  }
@@ -1612,8 +1610,7 @@ static enum undo_level init_intr(struct cxlflash_cfg *cfg,
  rc = cxl_map_afu_irq(ctx, 3, cxlflash_async_err_irq, afu,
      "SISL_MSI_ASYNC_ERROR");
  if (unlikely(rc <= 0)) {
- dev_err(dev, "%s: IRQ 3 (SISL_MSI_ASYNC_ERROR) map failed!\n",
- __func__);
+ dev_err(dev, "%s: SISL_MSI_ASYNC_ERROR map failed\n", __func__);
  level = UNMAP_TWO;
  goto out;
  }
@@ -1647,15 +1644,13 @@ static int init_mc(struct cxlflash_cfg *cfg)
  /* During initialization reset the AFU to start from a clean slate */
  rc = cxl_afu_reset(cfg->mcctx);
  if (unlikely(rc)) {
- dev_err(dev, "%s: initial AFU reset failed rc=%d\n",
- __func__, rc);
+ dev_err(dev, "%s: AFU reset failed rc=%d\n", __func__, rc);
  goto ret;
  }
 
  level = init_intr(cfg, ctx);
  if (unlikely(level)) {
- dev_err(dev, "%s: setting up interrupts failed rc=%d\n",
- __func__, rc);
+ dev_err(dev, "%s: interrupt init failed rc=%d\n", __func__, rc);
  goto out;
  }
 
@@ -1670,7 +1665,7 @@ static int init_mc(struct cxlflash_cfg *cfg)
  goto out;
  }
 ret:
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 out:
  term_intr(cfg, level);
@@ -1697,7 +1692,7 @@ static int init_afu(struct cxlflash_cfg *cfg)
 
  rc = init_mc(cfg);
  if (rc) {
- dev_err(dev, "%s: call to init_mc failed, rc=%d!\n",
+ dev_err(dev, "%s: init_mc failed rc=%d\n",
  __func__, rc);
  goto out;
  }
@@ -1705,7 +1700,7 @@ static int init_afu(struct cxlflash_cfg *cfg)
  /* Map the entire MMIO space of the AFU */
  afu->afu_map = cxl_psa_map(cfg->mcctx);
  if (!afu->afu_map) {
- dev_err(dev, "%s: call to cxl_psa_map failed!\n", __func__);
+ dev_err(dev, "%s: cxl_psa_map failed\n", __func__);
  rc = -ENOMEM;
  goto err1;
  }
@@ -1717,8 +1712,8 @@ static int init_afu(struct cxlflash_cfg *cfg)
  afu->interface_version =
     readq_be(&afu->afu_map->global.regs.interface_version);
  if ((afu->interface_version + 1) == 0) {
- pr_err("Back level AFU, please upgrade. AFU version %s "
-       "interface version 0x%llx\n", afu->version,
+ dev_err(dev, "Back level AFU, please upgrade. AFU version %s "
+ "interface version %016llx\n", afu->version,
        afu->interface_version);
  rc = -EINVAL;
  goto err2;
@@ -1732,13 +1727,12 @@ static int init_afu(struct cxlflash_cfg *cfg)
  afu->context_reset = context_reset_ioarrin;
  }
 
- pr_debug("%s: afu version %s, interface version 0x%llX\n", __func__,
- afu->version, afu->interface_version);
+ dev_dbg(dev, "%s: afu_ver=%s interface_ver=%016llx\n", __func__,
+ afu->version, afu->interface_version);
 
  rc = start_afu(cfg);
  if (rc) {
- dev_err(dev, "%s: call to start_afu failed, rc=%d!\n",
- __func__, rc);
+ dev_err(dev, "%s: start_afu failed, rc=%d\n", __func__, rc);
  goto err2;
  }
 
@@ -1749,7 +1743,7 @@ static int init_afu(struct cxlflash_cfg *cfg)
  /* Restore the LUN mappings */
  cxlflash_restore_luntable(cfg);
 out:
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 
 err2:
@@ -1793,7 +1787,8 @@ int cxlflash_afu_sync(struct afu *afu, ctx_hndl_t ctx_hndl_u,
  static DEFINE_MUTEX(sync_active);
 
  if (cfg->state != STATE_NORMAL) {
- pr_debug("%s: Sync not required! (%u)\n", __func__, cfg->state);
+ dev_dbg(dev, "%s: Sync not required state=%u\n",
+ __func__, cfg->state);
  return 0;
  }
 
@@ -1810,7 +1805,7 @@ int cxlflash_afu_sync(struct afu *afu, ctx_hndl_t ctx_hndl_u,
  init_completion(&cmd->cevent);
  cmd->parent = afu;
 
- pr_debug("%s: afu=%p cmd=%p %d\n", __func__, afu, cmd, ctx_hndl_u);
+ dev_dbg(dev, "%s: afu=%p cmd=%p %d\n", __func__, afu, cmd, ctx_hndl_u);
 
  cmd->rcb.req_flags = SISL_REQ_FLAGS_AFU_CMD;
  cmd->rcb.ctx_id = afu->ctx_hndl;
@@ -1835,7 +1830,7 @@ int cxlflash_afu_sync(struct afu *afu, ctx_hndl_t ctx_hndl_u,
  atomic_dec(&afu->cmds_active);
  mutex_unlock(&sync_active);
  kfree(buf);
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -1847,16 +1842,17 @@ int cxlflash_afu_sync(struct afu *afu, ctx_hndl_t ctx_hndl_u,
  */
 static int afu_reset(struct cxlflash_cfg *cfg)
 {
+ struct device *dev = &cfg->dev->dev;
  int rc = 0;
+
  /* Stop the context before the reset. Since the context is
  * no longer available restart it after the reset is complete
  */
-
  term_afu(cfg);
 
  rc = init_afu(cfg);
 
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -1885,18 +1881,18 @@ static int cxlflash_eh_device_reset_handler(struct scsi_cmnd *scp)
 {
  int rc = SUCCESS;
  struct Scsi_Host *host = scp->device->host;
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(host);
+ struct device *dev = &cfg->dev->dev;
  struct afu *afu = cfg->afu;
  int rcr = 0;
 
- pr_debug("%s: (scp=%p) %d/%d/%d/%llu "
- "cdb=(%08X-%08X-%08X-%08X)\n", __func__, scp,
- host->host_no, scp->device->channel,
- scp->device->id, scp->device->lun,
- get_unaligned_be32(&((u32 *)scp->cmnd)[0]),
- get_unaligned_be32(&((u32 *)scp->cmnd)[1]),
- get_unaligned_be32(&((u32 *)scp->cmnd)[2]),
- get_unaligned_be32(&((u32 *)scp->cmnd)[3]));
+ dev_dbg(dev, "%s: (scp=%p) %d/%d/%d/%llu "
+ "cdb=(%08x-%08x-%08x-%08x)\n", __func__, scp, host->host_no,
+ scp->device->channel, scp->device->id, scp->device->lun,
+ get_unaligned_be32(&((u32 *)scp->cmnd)[0]),
+ get_unaligned_be32(&((u32 *)scp->cmnd)[1]),
+ get_unaligned_be32(&((u32 *)scp->cmnd)[2]),
+ get_unaligned_be32(&((u32 *)scp->cmnd)[3]));
 
 retry:
  switch (cfg->state) {
@@ -1913,7 +1909,7 @@ static int cxlflash_eh_device_reset_handler(struct scsi_cmnd *scp)
  break;
  }
 
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -1935,16 +1931,16 @@ static int cxlflash_eh_host_reset_handler(struct scsi_cmnd *scp)
  int rc = SUCCESS;
  int rcr = 0;
  struct Scsi_Host *host = scp->device->host;
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(host);
+ struct device *dev = &cfg->dev->dev;
 
- pr_debug("%s: (scp=%p) %d/%d/%d/%llu "
- "cdb=(%08X-%08X-%08X-%08X)\n", __func__, scp,
- host->host_no, scp->device->channel,
- scp->device->id, scp->device->lun,
- get_unaligned_be32(&((u32 *)scp->cmnd)[0]),
- get_unaligned_be32(&((u32 *)scp->cmnd)[1]),
- get_unaligned_be32(&((u32 *)scp->cmnd)[2]),
- get_unaligned_be32(&((u32 *)scp->cmnd)[3]));
+ dev_dbg(dev, "%s: (scp=%p) %d/%d/%d/%llu "
+ "cdb=(%08x-%08x-%08x-%08x)\n", __func__, scp, host->host_no,
+ scp->device->channel, scp->device->id, scp->device->lun,
+ get_unaligned_be32(&((u32 *)scp->cmnd)[0]),
+ get_unaligned_be32(&((u32 *)scp->cmnd)[1]),
+ get_unaligned_be32(&((u32 *)scp->cmnd)[2]),
+ get_unaligned_be32(&((u32 *)scp->cmnd)[3]));
 
  switch (cfg->state) {
  case STATE_NORMAL:
@@ -1970,7 +1966,7 @@ static int cxlflash_eh_host_reset_handler(struct scsi_cmnd *scp)
  break;
  }
 
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -2036,8 +2032,7 @@ static ssize_t port0_show(struct device *dev,
   struct device_attribute *attr,
   char *buf)
 {
- struct Scsi_Host *shost = class_to_shost(dev);
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)shost->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
  struct afu *afu = cfg->afu;
 
  return cxlflash_show_port_status(0, afu, buf);
@@ -2055,8 +2050,7 @@ static ssize_t port1_show(struct device *dev,
   struct device_attribute *attr,
   char *buf)
 {
- struct Scsi_Host *shost = class_to_shost(dev);
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)shost->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
  struct afu *afu = cfg->afu;
 
  return cxlflash_show_port_status(1, afu, buf);
@@ -2073,8 +2067,7 @@ static ssize_t port1_show(struct device *dev,
 static ssize_t lun_mode_show(struct device *dev,
      struct device_attribute *attr, char *buf)
 {
- struct Scsi_Host *shost = class_to_shost(dev);
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)shost->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
  struct afu *afu = cfg->afu;
 
  return scnprintf(buf, PAGE_SIZE, "%u\n", afu->internal_lun);
@@ -2107,7 +2100,7 @@ static ssize_t lun_mode_store(struct device *dev,
       const char *buf, size_t count)
 {
  struct Scsi_Host *shost = class_to_shost(dev);
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)shost->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(shost);
  struct afu *afu = cfg->afu;
  int rc;
  u32 lun_mode;
@@ -2169,7 +2162,7 @@ static ssize_t cxlflash_show_port_lun_table(u32 port,
 
  for (i = 0; i < CXLFLASH_NUM_VLUNS; i++)
  bytes += scnprintf(buf + bytes, PAGE_SIZE - bytes,
-   "%03d: %016llX\n", i, readq_be(&fc_port[i]));
+   "%03d: %016llx\n", i, readq_be(&fc_port[i]));
  return bytes;
 }
 
@@ -2185,8 +2178,7 @@ static ssize_t port0_lun_table_show(struct device *dev,
     struct device_attribute *attr,
     char *buf)
 {
- struct Scsi_Host *shost = class_to_shost(dev);
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)shost->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
  struct afu *afu = cfg->afu;
 
  return cxlflash_show_port_lun_table(0, afu, buf);
@@ -2204,8 +2196,7 @@ static ssize_t port1_lun_table_show(struct device *dev,
     struct device_attribute *attr,
     char *buf)
 {
- struct Scsi_Host *shost = class_to_shost(dev);
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)shost->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
  struct afu *afu = cfg->afu;
 
  return cxlflash_show_port_lun_table(1, afu, buf);
@@ -2365,6 +2356,7 @@ static int cxlflash_probe(struct pci_dev *pdev,
 {
  struct Scsi_Host *host;
  struct cxlflash_cfg *cfg = NULL;
+ struct device *dev = &pdev->dev;
  struct dev_dependent_vals *ddv;
  int rc = 0;
 
@@ -2376,8 +2368,7 @@ static int cxlflash_probe(struct pci_dev *pdev,
 
  host = scsi_host_alloc(&driver_template, sizeof(struct cxlflash_cfg));
  if (!host) {
- dev_err(&pdev->dev, "%s: call to scsi_host_alloc failed!\n",
- __func__);
+ dev_err(dev, "%s: scsi_host_alloc failed\n", __func__);
  rc = -ENOMEM;
  goto out;
  }
@@ -2388,12 +2379,11 @@ static int cxlflash_probe(struct pci_dev *pdev,
  host->unique_id = host->host_no;
  host->max_cmd_len = CXLFLASH_MAX_CDB_LEN;
 
- cfg = (struct cxlflash_cfg *)host->hostdata;
+ cfg = shost_priv(host);
  cfg->host = host;
  rc = alloc_mem(cfg);
  if (rc) {
- dev_err(&pdev->dev, "%s: call to alloc_mem failed!\n",
- __func__);
+ dev_err(dev, "%s: alloc_mem failed\n", __func__);
  rc = -ENOMEM;
  scsi_host_put(cfg->host);
  goto out;
@@ -2434,30 +2424,27 @@ static int cxlflash_probe(struct pci_dev *pdev,
 
  rc = init_pci(cfg);
  if (rc) {
- dev_err(&pdev->dev, "%s: call to init_pci "
- "failed rc=%d!\n", __func__, rc);
+ dev_err(dev, "%s: init_pci failed rc=%d\n", __func__, rc);
  goto out_remove;
  }
  cfg->init_state = INIT_STATE_PCI;
 
  rc = init_afu(cfg);
  if (rc) {
- dev_err(&pdev->dev, "%s: call to init_afu "
- "failed rc=%d!\n", __func__, rc);
+ dev_err(dev, "%s: init_afu failed rc=%d\n", __func__, rc);
  goto out_remove;
  }
  cfg->init_state = INIT_STATE_AFU;
 
  rc = init_scsi(cfg);
  if (rc) {
- dev_err(&pdev->dev, "%s: call to init_scsi "
- "failed rc=%d!\n", __func__, rc);
+ dev_err(dev, "%s: init_scsi failed rc=%d\n", __func__, rc);
  goto out_remove;
  }
  cfg->init_state = INIT_STATE_SCSI;
 
 out:
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 
 out_remove:
@@ -2495,7 +2482,7 @@ static pci_ers_result_t cxlflash_pci_error_detected(struct pci_dev *pdev,
  drain_ioctls(cfg);
  rc = cxlflash_mark_contexts_error(cfg);
  if (unlikely(rc))
- dev_err(dev, "%s: Failed to mark user contexts!(%d)\n",
+ dev_err(dev, "%s: Failed to mark user contexts rc=%d\n",
  __func__, rc);
  term_afu(cfg);
  return PCI_ERS_RESULT_NEED_RESET;
@@ -2529,7 +2516,7 @@ static pci_ers_result_t cxlflash_pci_slot_reset(struct pci_dev *pdev)
 
  rc = init_afu(cfg);
  if (unlikely(rc)) {
- dev_err(dev, "%s: EEH recovery failed! (%d)\n", __func__, rc);
+ dev_err(dev, "%s: EEH recovery failed rc=%d\n", __func__, rc);
  return PCI_ERS_RESULT_DISCONNECT;
  }
 
@@ -2577,8 +2564,6 @@ static struct pci_driver cxlflash_driver = {
  */
 static int __init init_cxlflash(void)
 {
- pr_info("%s: %s\n", __func__, CXLFLASH_ADAPTER_NAME);
-
  cxlflash_list_init();
 
  return pci_register_driver(&cxlflash_driver);
diff --git a/drivers/scsi/cxlflash/superpipe.c b/drivers/scsi/cxlflash/superpipe.c
index 42674ae6f4dd..90869cee2b20 100644
--- a/drivers/scsi/cxlflash/superpipe.c
+++ b/drivers/scsi/cxlflash/superpipe.c
@@ -212,7 +212,7 @@ struct ctx_info *get_context(struct cxlflash_cfg *cfg, u64 rctxid,
  }
 
 out:
- dev_dbg(dev, "%s: rctxid=%016llX ctxinfo=%p ctxpid=%u pid=%u "
+ dev_dbg(dev, "%s: rctxid=%016llx ctxinfo=%p ctxpid=%u pid=%u "
  "ctx_ctrl=%u\n", __func__, rctxid, ctxi, ctxpid, pid,
  ctx_ctrl);
 
@@ -260,7 +260,7 @@ static int afu_attach(struct cxlflash_cfg *cfg, struct ctx_info *ctxi)
  writeq_be(val, &ctrl_map->ctx_cap);
  val = readq_be(&ctrl_map->ctx_cap);
  if (val != (SISL_CTX_CAP_READ_CMD | SISL_CTX_CAP_WRITE_CMD)) {
- dev_err(dev, "%s: ctx may be closed val=%016llX\n",
+ dev_err(dev, "%s: ctx may be closed val=%016llx\n",
  __func__, val);
  rc = -EAGAIN;
  goto out;
@@ -302,7 +302,7 @@ static int afu_attach(struct cxlflash_cfg *cfg, struct ctx_info *ctxi)
  */
 static int read_cap16(struct scsi_device *sdev, struct llun_info *lli)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
  struct glun_info *gli = lli->parent;
  u8 *cmd_buf = NULL;
@@ -326,7 +326,7 @@ static int read_cap16(struct scsi_device *sdev, struct llun_info *lli)
  scsi_cmd[1] = SAI_READ_CAPACITY_16; /* service action */
  put_unaligned_be32(CMD_BUFSIZE, &scsi_cmd[10]);
 
- dev_dbg(dev, "%s: %ssending cmd(0x%x)\n", __func__,
+ dev_dbg(dev, "%s: %ssending cmd(%02x)\n", __func__,
  retry_cnt ? "re" : "", scsi_cmd[0]);
 
  /* Drop the ioctl read semahpore across lengthy call */
@@ -336,7 +336,7 @@ static int read_cap16(struct scsi_device *sdev, struct llun_info *lli)
  down_read(&cfg->ioctl_rwsem);
  rc = check_state(cfg);
  if (rc) {
- dev_err(dev, "%s: Failed state! result=0x08%X\n",
+ dev_err(dev, "%s: Failed state result=%08x\n",
  __func__, result);
  rc = -ENODEV;
  goto out;
@@ -378,7 +378,7 @@ static int read_cap16(struct scsi_device *sdev, struct llun_info *lli)
  }
 
  if (result) {
- dev_err(dev, "%s: command failed, result=0x%x\n",
+ dev_err(dev, "%s: command failed, result=%08x\n",
  __func__, result);
  rc = -EIO;
  goto out;
@@ -415,29 +415,32 @@ static int read_cap16(struct scsi_device *sdev, struct llun_info *lli)
 struct sisl_rht_entry *get_rhte(struct ctx_info *ctxi, res_hndl_t rhndl,
  struct llun_info *lli)
 {
+ struct cxlflash_cfg *cfg = ctxi->cfg;
+ struct device *dev = &cfg->dev->dev;
  struct sisl_rht_entry *rhte = NULL;
 
  if (unlikely(!ctxi->rht_start)) {
- pr_debug("%s: Context does not have allocated RHT!\n",
+ dev_dbg(dev, "%s: Context does not have allocated RHT\n",
  __func__);
  goto out;
  }
 
  if (unlikely(rhndl >= MAX_RHT_PER_CONTEXT)) {
- pr_debug("%s: Bad resource handle! (%d)\n", __func__, rhndl);
+ dev_dbg(dev, "%s: Bad resource handle rhndl=%d\n",
+ __func__, rhndl);
  goto out;
  }
 
  if (unlikely(ctxi->rht_lun[rhndl] != lli)) {
- pr_debug("%s: Bad resource handle LUN! (%d)\n",
- __func__, rhndl);
+ dev_dbg(dev, "%s: Bad resource handle LUN rhndl=%d\n",
+ __func__, rhndl);
  goto out;
  }
 
  rhte = &ctxi->rht_start[rhndl];
  if (unlikely(rhte->nmask == 0)) {
- pr_debug("%s: Unopened resource handle! (%d)\n",
- __func__, rhndl);
+ dev_dbg(dev, "%s: Unopened resource handle rhndl=%d\n",
+ __func__, rhndl);
  rhte = NULL;
  goto out;
  }
@@ -456,6 +459,8 @@ struct sisl_rht_entry *get_rhte(struct ctx_info *ctxi, res_hndl_t rhndl,
 struct sisl_rht_entry *rhte_checkout(struct ctx_info *ctxi,
      struct llun_info *lli)
 {
+ struct cxlflash_cfg *cfg = ctxi->cfg;
+ struct device *dev = &cfg->dev->dev;
  struct sisl_rht_entry *rhte = NULL;
  int i;
 
@@ -470,7 +475,7 @@ struct sisl_rht_entry *rhte_checkout(struct ctx_info *ctxi,
  if (likely(rhte))
  ctxi->rht_lun[i] = lli;
 
- pr_debug("%s: returning rhte=%p (%d)\n", __func__, rhte, i);
+ dev_dbg(dev, "%s: returning rhte=%p index=%d\n", __func__, rhte, i);
  return rhte;
 }
 
@@ -547,7 +552,7 @@ int cxlflash_lun_attach(struct glun_info *gli, enum lun_mode mode, bool locked)
  if (gli->mode == MODE_NONE)
  gli->mode = mode;
  else if (gli->mode != mode) {
- pr_debug("%s: LUN operating in mode %d, requested mode %d\n",
+ pr_debug("%s: gli_mode=%d requested_mode=%d\n",
  __func__, gli->mode, mode);
  rc = -EINVAL;
  goto out;
@@ -605,7 +610,7 @@ int _cxlflash_disk_release(struct scsi_device *sdev,
    struct ctx_info *ctxi,
    struct dk_cxlflash_release *release)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = sdev->hostdata;
  struct glun_info *gli = lli->parent;
@@ -622,13 +627,13 @@ int _cxlflash_disk_release(struct scsi_device *sdev,
  struct sisl_rht_entry *rhte;
  struct sisl_rht_entry_f1 *rhte_f1;
 
- dev_dbg(dev, "%s: ctxid=%llu rhndl=0x%llx gli->mode=%u gli->users=%u\n",
+ dev_dbg(dev, "%s: ctxid=%llu rhndl=%llu gli->mode=%u gli->users=%u\n",
  __func__, ctxid, release->rsrc_handle, gli->mode, gli->users);
 
  if (!ctxi) {
  ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK);
  if (unlikely(!ctxi)) {
- dev_dbg(dev, "%s: Bad context! (%llu)\n",
+ dev_dbg(dev, "%s: Bad context ctxid=%llu\n",
  __func__, ctxid);
  rc = -EINVAL;
  goto out;
@@ -639,7 +644,7 @@ int _cxlflash_disk_release(struct scsi_device *sdev,
 
  rhte = get_rhte(ctxi, rhndl, lli);
  if (unlikely(!rhte)) {
- dev_dbg(dev, "%s: Bad resource handle! (%d)\n",
+ dev_dbg(dev, "%s: Bad resource handle rhndl=%d\n",
  __func__, rhndl);
  rc = -EINVAL;
  goto out;
@@ -758,13 +763,13 @@ static struct ctx_info *create_context(struct cxlflash_cfg *cfg)
  lli = kzalloc((MAX_RHT_PER_CONTEXT * sizeof(*lli)), GFP_KERNEL);
  ws = kzalloc((MAX_RHT_PER_CONTEXT * sizeof(*ws)), GFP_KERNEL);
  if (unlikely(!ctxi || !lli || !ws)) {
- dev_err(dev, "%s: Unable to allocate context!\n", __func__);
+ dev_err(dev, "%s: Unable to allocate context\n", __func__);
  goto err;
  }
 
  rhte = (struct sisl_rht_entry *)get_zeroed_page(GFP_KERNEL);
  if (unlikely(!rhte)) {
- dev_err(dev, "%s: Unable to allocate RHT!\n", __func__);
+ dev_err(dev, "%s: Unable to allocate RHT\n", __func__);
  goto err;
  }
 
@@ -858,7 +863,7 @@ static int _cxlflash_disk_detach(struct scsi_device *sdev,
  struct ctx_info *ctxi,
  struct dk_cxlflash_detach *detach)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = sdev->hostdata;
  struct lun_access *lun_access, *t;
@@ -875,7 +880,7 @@ static int _cxlflash_disk_detach(struct scsi_device *sdev,
  if (!ctxi) {
  ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK);
  if (unlikely(!ctxi)) {
- dev_dbg(dev, "%s: Bad context! (%llu)\n",
+ dev_dbg(dev, "%s: Bad context ctxid=%llu\n",
  __func__, ctxid);
  rc = -EINVAL;
  goto out;
@@ -964,7 +969,7 @@ static int cxlflash_cxl_release(struct inode *inode, struct file *file)
 
  ctxid = cxl_process_element(ctx);
  if (unlikely(ctxid < 0)) {
- dev_err(dev, "%s: Context %p was closed! (%d)\n",
+ dev_err(dev, "%s: Context %p was closed ctxid=%d\n",
  __func__, ctx, ctxid);
  goto out;
  }
@@ -973,18 +978,18 @@ static int cxlflash_cxl_release(struct inode *inode, struct file *file)
  if (unlikely(!ctxi)) {
  ctxi = get_context(cfg, ctxid, file, ctrl | CTX_CTRL_CLONE);
  if (!ctxi) {
- dev_dbg(dev, "%s: Context %d already free!\n",
+ dev_dbg(dev, "%s: ctxid=%d already free\n",
  __func__, ctxid);
  goto out_release;
  }
 
- dev_dbg(dev, "%s: Another process owns context %d!\n",
+ dev_dbg(dev, "%s: Another process owns ctxid=%d\n",
  __func__, ctxid);
  put_context(ctxi);
  goto out;
  }
 
- dev_dbg(dev, "%s: close for context %d\n", __func__, ctxid);
+ dev_dbg(dev, "%s: close for ctxid=%d\n", __func__, ctxid);
 
  detach.context_id = ctxi->ctxid;
  list_for_each_entry_safe(lun_access, t, &ctxi->luns, list)
@@ -1011,17 +1016,20 @@ static void unmap_context(struct ctx_info *ctxi)
 
 /**
  * get_err_page() - obtains and allocates the error notification page
+ * @cfg: Internal structure associated with the host.
  *
  * Return: error notification page on success, NULL on failure
  */
-static struct page *get_err_page(void)
+static struct page *get_err_page(struct cxlflash_cfg *cfg)
 {
  struct page *err_page = global.err_page;
+ struct device *dev = &cfg->dev->dev;
 
  if (unlikely(!err_page)) {
  err_page = alloc_page(GFP_KERNEL);
  if (unlikely(!err_page)) {
- pr_err("%s: Unable to allocate err_page!\n", __func__);
+ dev_err(dev, "%s: Unable to allocate err_page\n",
+ __func__);
  goto out;
  }
 
@@ -1039,7 +1047,7 @@ static struct page *get_err_page(void)
  }
 
 out:
- pr_debug("%s: returning err_page=%p\n", __func__, err_page);
+ dev_dbg(dev, "%s: returning err_page=%p\n", __func__, err_page);
  return err_page;
 }
 
@@ -1074,14 +1082,14 @@ static int cxlflash_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 
  ctxid = cxl_process_element(ctx);
  if (unlikely(ctxid < 0)) {
- dev_err(dev, "%s: Context %p was closed! (%d)\n",
+ dev_err(dev, "%s: Context %p was closed ctxid=%d\n",
  __func__, ctx, ctxid);
  goto err;
  }
 
  ctxi = get_context(cfg, ctxid, file, ctrl);
  if (unlikely(!ctxi)) {
- dev_dbg(dev, "%s: Bad context! (%d)\n", __func__, ctxid);
+ dev_dbg(dev, "%s: Bad context ctxid=%d\n", __func__, ctxid);
  goto err;
  }
 
@@ -1091,13 +1099,12 @@ static int cxlflash_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
  vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
  rc = ctxi->cxl_mmap_vmops->fault(vma, vmf);
  } else {
- dev_dbg(dev, "%s: err recovery active, use err_page!\n",
+ dev_dbg(dev, "%s: err recovery active, use err_page\n",
  __func__);
 
- err_page = get_err_page();
+ err_page = get_err_page(cfg);
  if (unlikely(!err_page)) {
- dev_err(dev, "%s: Could not obtain error page!\n",
- __func__);
+ dev_err(dev, "%s: Could not get err_page\n", __func__);
  rc = VM_FAULT_RETRY;
  goto out;
  }
@@ -1147,7 +1154,7 @@ static int cxlflash_cxl_mmap(struct file *file, struct vm_area_struct *vma)
 
  ctxid = cxl_process_element(ctx);
  if (unlikely(ctxid < 0)) {
- dev_err(dev, "%s: Context %p was closed! (%d)\n",
+ dev_err(dev, "%s: Context %p was closed ctxid=%d\n",
  __func__, ctx, ctxid);
  rc = -EIO;
  goto out;
@@ -1155,7 +1162,7 @@ static int cxlflash_cxl_mmap(struct file *file, struct vm_area_struct *vma)
 
  ctxi = get_context(cfg, ctxid, file, ctrl);
  if (unlikely(!ctxi)) {
- dev_dbg(dev, "%s: Bad context! (%d)\n", __func__, ctxid);
+ dev_dbg(dev, "%s: Bad context ctxid=%d\n", __func__, ctxid);
  rc = -EIO;
  goto out;
  }
@@ -1251,7 +1258,7 @@ int check_state(struct cxlflash_cfg *cfg)
  break;
  goto retry;
  case STATE_FAILTERM:
- dev_dbg(dev, "%s: Failed/Terminating!\n", __func__);
+ dev_dbg(dev, "%s: Failed/Terminating\n", __func__);
  rc = -ENODEV;
  break;
  default:
@@ -1276,7 +1283,7 @@ int check_state(struct cxlflash_cfg *cfg)
 static int cxlflash_disk_attach(struct scsi_device *sdev,
  struct dk_cxlflash_attach *attach)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
  struct afu *afu = cfg->afu;
  struct llun_info *lli = sdev->hostdata;
@@ -1303,24 +1310,24 @@ static int cxlflash_disk_attach(struct scsi_device *sdev,
  }
 
  if (gli->max_lba == 0) {
- dev_dbg(dev, "%s: No capacity info for this LUN (%016llX)\n",
+ dev_dbg(dev, "%s: No capacity info for LUN=%016llx\n",
  __func__, lli->lun_id[sdev->channel]);
  rc = read_cap16(sdev, lli);
  if (rc) {
- dev_err(dev, "%s: Invalid device! (%d)\n",
+ dev_err(dev, "%s: Invalid device rc=%d\n",
  __func__, rc);
  rc = -ENODEV;
  goto out;
  }
- dev_dbg(dev, "%s: LBA = %016llX\n", __func__, gli->max_lba);
- dev_dbg(dev, "%s: BLK_LEN = %08X\n", __func__, gli->blk_len);
+ dev_dbg(dev, "%s: LBA = %016llx\n", __func__, gli->max_lba);
+ dev_dbg(dev, "%s: BLK_LEN = %08x\n", __func__, gli->blk_len);
  }
 
  if (attach->hdr.flags & DK_CXLFLASH_ATTACH_REUSE_CONTEXT) {
  rctxid = attach->context_id;
  ctxi = get_context(cfg, rctxid, NULL, 0);
  if (!ctxi) {
- dev_dbg(dev, "%s: Bad context! (%016llX)\n",
+ dev_dbg(dev, "%s: Bad context rctxid=%016llx\n",
  __func__, rctxid);
  rc = -EINVAL;
  goto out;
@@ -1328,7 +1335,7 @@ static int cxlflash_disk_attach(struct scsi_device *sdev,
 
  list_for_each_entry(lun_access, &ctxi->luns, list)
  if (lun_access->lli == lli) {
- dev_dbg(dev, "%s: Already attached!\n",
+ dev_dbg(dev, "%s: Already attached\n",
  __func__);
  rc = -EINVAL;
  goto out;
@@ -1337,13 +1344,13 @@ static int cxlflash_disk_attach(struct scsi_device *sdev,
 
  rc = scsi_device_get(sdev);
  if (unlikely(rc)) {
- dev_err(dev, "%s: Unable to get sdev reference!\n", __func__);
+ dev_err(dev, "%s: Unable to get sdev reference\n", __func__);
  goto out;
  }
 
  lun_access = kzalloc(sizeof(*lun_access), GFP_KERNEL);
  if (unlikely(!lun_access)) {
- dev_err(dev, "%s: Unable to allocate lun_access!\n", __func__);
+ dev_err(dev, "%s: Unable to allocate lun_access\n", __func__);
  rc = -ENOMEM;
  goto err;
  }
@@ -1353,7 +1360,7 @@ static int cxlflash_disk_attach(struct scsi_device *sdev,
 
  /* Non-NULL context indicates reuse (another context reference) */
  if (ctxi) {
- dev_dbg(dev, "%s: Reusing context for LUN! (%016llX)\n",
+ dev_dbg(dev, "%s: Reusing context for LUN rctxid=%016llx\n",
  __func__, rctxid);
  kref_get(&ctxi->kref);
  list_add(&lun_access->list, &ctxi->luns);
@@ -1362,7 +1369,7 @@ static int cxlflash_disk_attach(struct scsi_device *sdev,
 
  ctxi = create_context(cfg);
  if (unlikely(!ctxi)) {
- dev_err(dev, "%s: Failed to create context! (%d)\n",
+ dev_err(dev, "%s: Failed to create context ctxid=%d\n",
  __func__, ctxid);
  goto err;
  }
@@ -1388,7 +1395,7 @@ static int cxlflash_disk_attach(struct scsi_device *sdev,
 
  ctxid = cxl_process_element(ctx);
  if (unlikely((ctxid >= MAX_CONTEXT) || (ctxid < 0))) {
- dev_err(dev, "%s: ctxid (%d) invalid!\n", __func__, ctxid);
+ dev_err(dev, "%s: ctxid=%d invalid\n", __func__, ctxid);
  rc = -EPERM;
  goto err;
  }
@@ -1522,7 +1529,7 @@ static int recover_context(struct cxlflash_cfg *cfg,
 
  ctxid = cxl_process_element(ctx);
  if (unlikely((ctxid >= MAX_CONTEXT) || (ctxid < 0))) {
- dev_err(dev, "%s: ctxid (%d) invalid!\n", __func__, ctxid);
+ dev_err(dev, "%s: ctxid=%d invalid\n", __func__, ctxid);
  rc = -EPERM;
  goto err2;
  }
@@ -1613,7 +1620,7 @@ static int recover_context(struct cxlflash_cfg *cfg,
 static int cxlflash_afu_recover(struct scsi_device *sdev,
  struct dk_cxlflash_recover_afu *recover)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = sdev->hostdata;
  struct afu *afu = cfg->afu;
@@ -1635,19 +1642,19 @@ static int cxlflash_afu_recover(struct scsi_device *sdev,
  goto out;
  rc = check_state(cfg);
  if (rc) {
- dev_err(dev, "%s: Failed state! rc=%d\n", __func__, rc);
+ dev_err(dev, "%s: Failed state rc=%d\n", __func__, rc);
  rc = -ENODEV;
  goto out;
  }
 
- dev_dbg(dev, "%s: reason 0x%016llX rctxid=%016llX\n",
+ dev_dbg(dev, "%s: reason=%016llx rctxid=%016llx\n",
  __func__, recover->reason, rctxid);
 
 retry:
  /* Ensure that this process is attached to the context */
  ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK);
  if (unlikely(!ctxi)) {
- dev_dbg(dev, "%s: Bad context! (%llu)\n", __func__, ctxid);
+ dev_dbg(dev, "%s: Bad context ctxid=%llu\n", __func__, ctxid);
  rc = -EINVAL;
  goto out;
  }
@@ -1656,12 +1663,12 @@ static int cxlflash_afu_recover(struct scsi_device *sdev,
 retry_recover:
  rc = recover_context(cfg, ctxi, &new_adap_fd);
  if (unlikely(rc)) {
- dev_err(dev, "%s: Recovery failed for context %llu (rc=%d)\n",
+ dev_err(dev, "%s: Recovery failed ctxid=%llu rc=%d\n",
  __func__, ctxid, rc);
  if ((rc == -ENODEV) &&
     ((atomic_read(&cfg->recovery_threads) > 1) ||
      (lretry--))) {
- dev_dbg(dev, "%s: Going to try again!\n",
+ dev_dbg(dev, "%s: Going to try again\n",
  __func__);
  mutex_unlock(mutex);
  msleep(100);
@@ -1707,7 +1714,7 @@ static int cxlflash_afu_recover(struct scsi_device *sdev,
  goto retry;
  }
 
- dev_dbg(dev, "%s: MMIO working, no recovery required!\n", __func__);
+ dev_dbg(dev, "%s: MMIO working, no recovery required\n", __func__);
 out:
  if (likely(ctxi))
  put_context(ctxi);
@@ -1726,7 +1733,7 @@ static int cxlflash_afu_recover(struct scsi_device *sdev,
 static int process_sense(struct scsi_device *sdev,
  struct dk_cxlflash_verify *verify)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = sdev->hostdata;
  struct glun_info *gli = lli->parent;
@@ -1737,7 +1744,7 @@ static int process_sense(struct scsi_device *sdev,
  rc = scsi_normalize_sense((const u8 *)&verify->sense_data,
   DK_CXLFLASH_VERIFY_SENSE_LEN, &sshdr);
  if (!rc) {
- dev_err(dev, "%s: Failed to normalize sense data!\n", __func__);
+ dev_err(dev, "%s: Failed to normalize sense data\n", __func__);
  rc = -EINVAL;
  goto out;
  }
@@ -1793,7 +1800,7 @@ static int cxlflash_disk_verify(struct scsi_device *sdev,
 {
  int rc = 0;
  struct ctx_info *ctxi = NULL;
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = sdev->hostdata;
  struct glun_info *gli = lli->parent;
@@ -1803,20 +1810,20 @@ static int cxlflash_disk_verify(struct scsi_device *sdev,
     rctxid = verify->context_id;
  u64 last_lba = 0;
 
- dev_dbg(dev, "%s: ctxid=%llu rhndl=%016llX, hint=%016llX, "
- "flags=%016llX\n", __func__, ctxid, verify->rsrc_handle,
+ dev_dbg(dev, "%s: ctxid=%llu rhndl=%016llx, hint=%016llx, "
+ "flags=%016llx\n", __func__, ctxid, verify->rsrc_handle,
  verify->hint, verify->hdr.flags);
 
  ctxi = get_context(cfg, rctxid, lli, 0);
  if (unlikely(!ctxi)) {
- dev_dbg(dev, "%s: Bad context! (%llu)\n", __func__, ctxid);
+ dev_dbg(dev, "%s: Bad context ctxid=%llu\n", __func__, ctxid);
  rc = -EINVAL;
  goto out;
  }
 
  rhte = get_rhte(ctxi, rhndl, lli);
  if (unlikely(!rhte)) {
- dev_dbg(dev, "%s: Bad resource handle! (%d)\n",
+ dev_dbg(dev, "%s: Bad resource handle rhndl=%d\n",
  __func__, rhndl);
  rc = -EINVAL;
  goto out;
@@ -1863,7 +1870,7 @@ static int cxlflash_disk_verify(struct scsi_device *sdev,
 out:
  if (likely(ctxi))
  put_context(ctxi);
- dev_dbg(dev, "%s: returning rc=%d llba=%llX\n",
+ dev_dbg(dev, "%s: returning rc=%d llba=%llx\n",
  __func__, rc, verify->last_lba);
  return rc;
 }
@@ -1915,7 +1922,7 @@ static char *decode_ioctl(int cmd)
  */
 static int cxlflash_disk_direct_open(struct scsi_device *sdev, void *arg)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
  struct afu *afu = cfg->afu;
  struct llun_info *lli = sdev->hostdata;
@@ -1935,25 +1942,25 @@ static int cxlflash_disk_direct_open(struct scsi_device *sdev, void *arg)
  struct ctx_info *ctxi = NULL;
  struct sisl_rht_entry *rhte = NULL;
 
- pr_debug("%s: ctxid=%llu ls=0x%llx\n", __func__, ctxid, lun_size);
+ dev_dbg(dev, "%s: ctxid=%llu ls=%llu\n", __func__, ctxid, lun_size);
 
  rc = cxlflash_lun_attach(gli, MODE_PHYSICAL, false);
  if (unlikely(rc)) {
- dev_dbg(dev, "%s: Failed to attach to LUN! (PHYSICAL)\n",
- __func__);
+ dev_dbg(dev, "%s: Failed attach to LUN (PHYSICAL)\n", __func__);
  goto out;
  }
 
  ctxi = get_context(cfg, rctxid, lli, 0);
  if (unlikely(!ctxi)) {
- dev_dbg(dev, "%s: Bad context! (%llu)\n", __func__, ctxid);
+ dev_dbg(dev, "%s: Bad context ctxid=%llu\n", __func__, ctxid);
  rc = -EINVAL;
  goto err1;
  }
 
  rhte = rhte_checkout(ctxi, lli);
  if (unlikely(!rhte)) {
- dev_dbg(dev, "%s: too many opens for this context\n", __func__);
+ dev_dbg(dev, "%s: Too many opens ctxid=%lld\n",
+ __func__, ctxid);
  rc = -EMFILE; /* too many opens  */
  goto err1;
  }
@@ -1971,7 +1978,7 @@ static int cxlflash_disk_direct_open(struct scsi_device *sdev, void *arg)
 out:
  if (likely(ctxi))
  put_context(ctxi);
- dev_dbg(dev, "%s: returning handle 0x%llx rc=%d llba %lld\n",
+ dev_dbg(dev, "%s: returning handle=%llu rc=%d llba=%llu\n",
  __func__, rsrc_handle, rc, last_lba);
  return rc;
 
@@ -1993,7 +2000,7 @@ static int cxlflash_disk_direct_open(struct scsi_device *sdev, void *arg)
  */
 static int ioctl_common(struct scsi_device *sdev, int cmd)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = sdev->hostdata;
  int rc = 0;
@@ -2010,7 +2017,7 @@ static int ioctl_common(struct scsi_device *sdev, int cmd)
  case DK_CXLFLASH_VLUN_RESIZE:
  case DK_CXLFLASH_RELEASE:
  case DK_CXLFLASH_DETACH:
- dev_dbg(dev, "%s: Command override! (%d)\n",
+ dev_dbg(dev, "%s: Command override rc=%d\n",
  __func__, rc);
  rc = 0;
  break;
@@ -2040,7 +2047,7 @@ int cxlflash_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
 {
  typedef int (*sioctl) (struct scsi_device *, void *);
 
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
  struct afu *afu = cfg->afu;
  struct dk_cxlflash_hdr *hdr;
@@ -2119,7 +2126,7 @@ int cxlflash_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
  }
 
  if (unlikely(copy_from_user(&buf, arg, size))) {
- dev_err(dev, "%s: copy_from_user() fail! "
+ dev_err(dev, "%s: copy_from_user() fail "
  "size=%lu cmd=%d (%s) arg=%p\n",
  __func__, size, cmd, decode_ioctl(cmd), arg);
  rc = -EFAULT;
@@ -2135,7 +2142,7 @@ int cxlflash_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
  }
 
  if (hdr->rsvd[0] || hdr->rsvd[1] || hdr->rsvd[2] || hdr->return_flags) {
- dev_dbg(dev, "%s: Reserved/rflags populated!\n", __func__);
+ dev_dbg(dev, "%s: Reserved/rflags populated\n", __func__);
  rc = -EINVAL;
  goto cxlflash_ioctl_exit;
  }
@@ -2143,7 +2150,7 @@ int cxlflash_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
  rc = do_ioctl(sdev, (void *)&buf);
  if (likely(!rc))
  if (unlikely(copy_to_user(arg, &buf, size))) {
- dev_err(dev, "%s: copy_to_user() fail! "
+ dev_err(dev, "%s: copy_to_user() fail "
  "size=%lu cmd=%d (%s) arg=%p\n",
  __func__, size, cmd, decode_ioctl(cmd), arg);
  rc = -EFAULT;
diff --git a/drivers/scsi/cxlflash/vlun.c b/drivers/scsi/cxlflash/vlun.c
index 90c5d7f5278e..8fcc804dbef9 100644
--- a/drivers/scsi/cxlflash/vlun.c
+++ b/drivers/scsi/cxlflash/vlun.c
@@ -66,8 +66,8 @@ static int ba_init(struct ba_lun *ba_lun)
  int last_word_underflow = 0;
  u64 *lam;
 
- pr_debug("%s: Initializing LUN: lun_id = %llX, "
- "ba_lun->lsize = %lX, ba_lun->au_size = %lX\n",
+ pr_debug("%s: Initializing LUN: lun_id=%016llx "
+ "ba_lun->lsize=%lx ba_lun->au_size=%lX\n",
  __func__, ba_lun->lun_id, ba_lun->lsize, ba_lun->au_size);
 
  /* Calculate bit map size */
@@ -80,7 +80,7 @@ static int ba_init(struct ba_lun *ba_lun)
  /* Allocate lun information container */
  bali = kzalloc(sizeof(struct ba_lun_info), GFP_KERNEL);
  if (unlikely(!bali)) {
- pr_err("%s: Failed to allocate lun_info for lun_id %llX\n",
+ pr_err("%s: Failed to allocate lun_info lun_id=%016llx\n",
        __func__, ba_lun->lun_id);
  return -ENOMEM;
  }
@@ -96,7 +96,7 @@ static int ba_init(struct ba_lun *ba_lun)
       GFP_KERNEL);
  if (unlikely(!bali->lun_alloc_map)) {
  pr_err("%s: Failed to allocate lun allocation map: "
-       "lun_id = %llX\n", __func__, ba_lun->lun_id);
+       "lun_id=%016llx\n", __func__, ba_lun->lun_id);
  kfree(bali);
  return -ENOMEM;
  }
@@ -125,7 +125,7 @@ static int ba_init(struct ba_lun *ba_lun)
  bali->aun_clone_map = kzalloc((bali->total_aus * sizeof(u8)),
       GFP_KERNEL);
  if (unlikely(!bali->aun_clone_map)) {
- pr_err("%s: Failed to allocate clone map: lun_id = %llX\n",
+ pr_err("%s: Failed to allocate clone map: lun_id=%016llx\n",
        __func__, ba_lun->lun_id);
  kfree(bali->lun_alloc_map);
  kfree(bali);
@@ -136,7 +136,7 @@ static int ba_init(struct ba_lun *ba_lun)
  ba_lun->ba_lun_handle = bali;
 
  pr_debug("%s: Successfully initialized the LUN: "
- "lun_id = %llX, bitmap size = %X, free_aun_cnt = %llX\n",
+ "lun_id=%016llx bitmap size=%x, free_aun_cnt=%llx\n",
  __func__, ba_lun->lun_id, bali->lun_bmap_size,
  bali->free_aun_cnt);
  return 0;
@@ -165,10 +165,9 @@ static int find_free_range(u32 low,
  num_bits = (sizeof(*lam) * BITS_PER_BYTE);
  bit_pos = find_first_bit(lam, num_bits);
 
- pr_devel("%s: Found free bit %llX in LUN "
- "map entry %llX at bitmap index = %X\n",
- __func__, bit_pos, bali->lun_alloc_map[i],
- i);
+ pr_devel("%s: Found free bit %llu in LUN "
+ "map entry %016llx at bitmap index = %d\n",
+ __func__, bit_pos, bali->lun_alloc_map[i], i);
 
  *bit_word = i;
  bali->free_aun_cnt--;
@@ -194,11 +193,11 @@ static u64 ba_alloc(struct ba_lun *ba_lun)
  bali = ba_lun->ba_lun_handle;
 
  pr_debug("%s: Received block allocation request: "
- "lun_id = %llX, free_aun_cnt = %llX\n",
+ "lun_id=%016llx free_aun_cnt=%llx\n",
  __func__, ba_lun->lun_id, bali->free_aun_cnt);
 
  if (bali->free_aun_cnt == 0) {
- pr_debug("%s: No space left on LUN: lun_id = %llX\n",
+ pr_debug("%s: No space left on LUN: lun_id=%016llx\n",
  __func__, ba_lun->lun_id);
  return -1ULL;
  }
@@ -212,7 +211,7 @@ static u64 ba_alloc(struct ba_lun *ba_lun)
   bali, &bit_word);
  if (bit_pos == -1) {
  pr_debug("%s: Could not find an allocation unit on LUN:"
- " lun_id = %llX\n", __func__, ba_lun->lun_id);
+ " lun_id=%016llx\n", __func__, ba_lun->lun_id);
  return -1ULL;
  }
  }
@@ -223,8 +222,8 @@ static u64 ba_alloc(struct ba_lun *ba_lun)
  else
  bali->free_curr_idx = bit_word;
 
- pr_debug("%s: Allocating AU number %llX, on lun_id %llX, "
- "free_aun_cnt = %llX\n", __func__,
+ pr_debug("%s: Allocating AU number=%llx lun_id=%016llx "
+ "free_aun_cnt=%llx\n", __func__,
  ((bit_word * BITS_PER_LONG) + bit_pos), ba_lun->lun_id,
  bali->free_aun_cnt);
 
@@ -266,18 +265,18 @@ static int ba_free(struct ba_lun *ba_lun, u64 to_free)
  bali = ba_lun->ba_lun_handle;
 
  if (validate_alloc(bali, to_free)) {
- pr_debug("%s: The AUN %llX is not allocated on lun_id %llX\n",
+ pr_debug("%s: AUN %llx is not allocated on lun_id=%016llx\n",
  __func__, to_free, ba_lun->lun_id);
  return -1;
  }
 
- pr_debug("%s: Received a request to free AU %llX on lun_id %llX, "
- "free_aun_cnt = %llX\n", __func__, to_free, ba_lun->lun_id,
+ pr_debug("%s: Received a request to free AU=%llx lun_id=%016llx "
+ "free_aun_cnt=%llx\n", __func__, to_free, ba_lun->lun_id,
  bali->free_aun_cnt);
 
  if (bali->aun_clone_map[to_free] > 0) {
- pr_debug("%s: AUN %llX on lun_id %llX has been cloned. Clone "
- "count = %X\n", __func__, to_free, ba_lun->lun_id,
+ pr_debug("%s: AUN %llx lun_id=%016llx cloned. Clone count=%x\n",
+ __func__, to_free, ba_lun->lun_id,
  bali->aun_clone_map[to_free]);
  bali->aun_clone_map[to_free]--;
  return 0;
@@ -294,8 +293,8 @@ static int ba_free(struct ba_lun *ba_lun, u64 to_free)
  else if (idx > bali->free_high_idx)
  bali->free_high_idx = idx;
 
- pr_debug("%s: Successfully freed AU at bit_pos %X, bit map index %X on "
- "lun_id %llX, free_aun_cnt = %llX\n", __func__, bit_pos, idx,
+ pr_debug("%s: Successfully freed AU bit_pos=%x bit map index=%x "
+ "lun_id=%016llx free_aun_cnt=%llx\n", __func__, bit_pos, idx,
  ba_lun->lun_id, bali->free_aun_cnt);
 
  return 0;
@@ -313,16 +312,16 @@ static int ba_clone(struct ba_lun *ba_lun, u64 to_clone)
  struct ba_lun_info *bali = ba_lun->ba_lun_handle;
 
  if (validate_alloc(bali, to_clone)) {
- pr_debug("%s: AUN %llX is not allocated on lun_id %llX\n",
+ pr_debug("%s: AUN=%llx not allocated on lun_id=%016llx\n",
  __func__, to_clone, ba_lun->lun_id);
  return -1;
  }
 
- pr_debug("%s: Received a request to clone AUN %llX on lun_id %llX\n",
+ pr_debug("%s: Received a request to clone AUN %llx on lun_id=%016llx\n",
  __func__, to_clone, ba_lun->lun_id);
 
  if (bali->aun_clone_map[to_clone] == MAX_AUN_CLONE_CNT) {
- pr_debug("%s: AUN %llX on lun_id %llX hit max clones already\n",
+ pr_debug("%s: AUN %llx on lun_id=%016llx hit max clones already\n",
  __func__, to_clone, ba_lun->lun_id);
  return -1;
  }
@@ -433,7 +432,7 @@ static int write_same16(struct scsi_device *sdev,
  u64 offset = lba;
  int left = nblks;
  u32 to = sdev->request_queue->rq_timeout;
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
 
  cmd_buf = kzalloc(CMD_BUFSIZE, GFP_KERNEL);
@@ -459,7 +458,7 @@ static int write_same16(struct scsi_device *sdev,
  down_read(&cfg->ioctl_rwsem);
  rc = check_state(cfg);
  if (rc) {
- dev_err(dev, "%s: Failed state! result=0x08%X\n",
+ dev_err(dev, "%s: Failed state result=%08x\n",
  __func__, result);
  rc = -ENODEV;
  goto out;
@@ -467,7 +466,7 @@ static int write_same16(struct scsi_device *sdev,
 
  if (result) {
  dev_err_ratelimited(dev, "%s: command failed for "
-    "offset %lld result=0x%x\n",
+    "offset=%lld result=%08x\n",
     __func__, offset, result);
  rc = -EIO;
  goto out;
@@ -480,7 +479,7 @@ static int write_same16(struct scsi_device *sdev,
  kfree(cmd_buf);
  kfree(scsi_cmd);
  kfree(sense_buf);
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -508,6 +507,8 @@ static int grow_lxt(struct afu *afu,
     struct sisl_rht_entry *rhte,
     u64 *new_size)
 {
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
+ struct device *dev = &cfg->dev->dev;
  struct sisl_lxt_entry *lxt = NULL, *lxt_old = NULL;
  struct llun_info *lli = sdev->hostdata;
  struct glun_info *gli = lli->parent;
@@ -527,7 +528,8 @@ static int grow_lxt(struct afu *afu,
  mutex_lock(&blka->mutex);
  av_size = ba_space(&blka->ba_lun);
  if (unlikely(av_size <= 0)) {
- pr_debug("%s: ba_space error: av_size %d\n", __func__, av_size);
+ dev_dbg(dev, "%s: ba_space error av_size=%d\n",
+ __func__, av_size);
  mutex_unlock(&blka->mutex);
  rc = -ENOSPC;
  goto out;
@@ -568,8 +570,8 @@ static int grow_lxt(struct afu *afu,
  */
  aun = ba_alloc(&blka->ba_lun);
  if ((aun == -1ULL) || (aun >= blka->nchunk))
- pr_debug("%s: ba_alloc error: allocated chunk# %llX, "
- "max %llX\n", __func__, aun, blka->nchunk - 1);
+ dev_dbg(dev, "%s: ba_alloc error allocated chunk=%llu "
+ "max=%llu\n", __func__, aun, blka->nchunk - 1);
 
  /* select both ports, use r/w perms from RHT */
  lxt[i].rlba_base = ((aun << MC_CHUNK_SHIFT) |
@@ -599,7 +601,7 @@ static int grow_lxt(struct afu *afu,
  kfree(lxt_old);
  *new_size = my_new_size;
 out:
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -621,6 +623,8 @@ static int shrink_lxt(struct afu *afu,
       struct ctx_info *ctxi,
       u64 *new_size)
 {
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
+ struct device *dev = &cfg->dev->dev;
  struct sisl_lxt_entry *lxt, *lxt_old;
  struct llun_info *lli = sdev->hostdata;
  struct glun_info *gli = lli->parent;
@@ -706,7 +710,7 @@ static int shrink_lxt(struct afu *afu,
  kfree(lxt_old);
  *new_size = my_new_size;
 out:
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -728,7 +732,8 @@ int _cxlflash_vlun_resize(struct scsi_device *sdev,
   struct ctx_info *ctxi,
   struct dk_cxlflash_resize *resize)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
+ struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = sdev->hostdata;
  struct glun_info *gli = lli->parent;
  struct afu *afu = cfg->afu;
@@ -751,13 +756,13 @@ int _cxlflash_vlun_resize(struct scsi_device *sdev,
  nsectors = (resize->req_size * CXLFLASH_BLOCK_SIZE) / gli->blk_len;
  new_size = DIV_ROUND_UP(nsectors, MC_CHUNK_SIZE);
 
- pr_debug("%s: ctxid=%llu rhndl=0x%llx, req_size=0x%llx,"
- "new_size=%llx\n", __func__, ctxid, resize->rsrc_handle,
- resize->req_size, new_size);
+ dev_dbg(dev, "%s: ctxid=%llu rhndl=%llu req_size=%llu new_size=%llu\n",
+ __func__, ctxid, resize->rsrc_handle, resize->req_size,
+ new_size);
 
  if (unlikely(gli->mode != MODE_VIRTUAL)) {
- pr_debug("%s: LUN mode does not support resize! (%d)\n",
- __func__, gli->mode);
+ dev_dbg(dev, "%s: LUN mode does not support resize mode=%d\n",
+ __func__, gli->mode);
  rc = -EINVAL;
  goto out;
 
@@ -766,7 +771,8 @@ int _cxlflash_vlun_resize(struct scsi_device *sdev,
  if (!ctxi) {
  ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK);
  if (unlikely(!ctxi)) {
- pr_debug("%s: Bad context! (%llu)\n", __func__, ctxid);
+ dev_dbg(dev, "%s: Bad context ctxid=%llu\n",
+ __func__, ctxid);
  rc = -EINVAL;
  goto out;
  }
@@ -776,7 +782,8 @@ int _cxlflash_vlun_resize(struct scsi_device *sdev,
 
  rhte = get_rhte(ctxi, rhndl, lli);
  if (unlikely(!rhte)) {
- pr_debug("%s: Bad resource handle! (%u)\n", __func__, rhndl);
+ dev_dbg(dev, "%s: Bad resource handle rhndl=%u\n",
+ __func__, rhndl);
  rc = -EINVAL;
  goto out;
  }
@@ -794,8 +801,8 @@ int _cxlflash_vlun_resize(struct scsi_device *sdev,
 out:
  if (put_ctx)
  put_context(ctxi);
- pr_debug("%s: resized to %lld returning rc=%d\n",
- __func__, resize->last_lba, rc);
+ dev_dbg(dev, "%s: resized to %llu returning rc=%d\n",
+ __func__, resize->last_lba, rc);
  return rc;
 }
 
@@ -815,6 +822,7 @@ void cxlflash_restore_luntable(struct cxlflash_cfg *cfg)
  u32 chan;
  u32 lind;
  struct afu *afu = cfg->afu;
+ struct device *dev = &cfg->dev->dev;
  struct sisl_global_map __iomem *agm = &afu->afu_map->global;
 
  mutex_lock(&global.mutex);
@@ -828,15 +836,15 @@ void cxlflash_restore_luntable(struct cxlflash_cfg *cfg)
  if (lli->port_sel == BOTH_PORTS) {
  writeq_be(lli->lun_id[0], &agm->fc_port[0][lind]);
  writeq_be(lli->lun_id[1], &agm->fc_port[1][lind]);
- pr_debug("%s: Virtual LUN on slot %d  id0=%llx, "
- "id1=%llx\n", __func__, lind,
- lli->lun_id[0], lli->lun_id[1]);
+ dev_dbg(dev, "%s: Virtual LUN on slot %d  id0=%llx "
+ "id1=%llx\n", __func__, lind,
+ lli->lun_id[0], lli->lun_id[1]);
  } else {
  chan = PORT2CHAN(lli->port_sel);
  writeq_be(lli->lun_id[chan], &agm->fc_port[chan][lind]);
- pr_debug("%s: Virtual LUN on slot %d chan=%d, "
- "id=%llx\n", __func__, lind, chan,
- lli->lun_id[chan]);
+ dev_dbg(dev, "%s: Virtual LUN on slot %d chan=%d "
+ "id=%llx\n", __func__, lind, chan,
+ lli->lun_id[chan]);
  }
  }
 
@@ -860,6 +868,7 @@ static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
  u32 lind;
  int rc = 0;
  struct afu *afu = cfg->afu;
+ struct device *dev = &cfg->dev->dev;
  struct sisl_global_map __iomem *agm = &afu->afu_map->global;
 
  mutex_lock(&global.mutex);
@@ -882,8 +891,8 @@ static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
  writeq_be(lli->lun_id[0], &agm->fc_port[0][lind]);
  writeq_be(lli->lun_id[1], &agm->fc_port[1][lind]);
  cfg->promote_lun_index++;
- pr_debug("%s: Virtual LUN on slot %d  id0=%llx, id1=%llx\n",
- __func__, lind, lli->lun_id[0], lli->lun_id[1]);
+ dev_dbg(dev, "%s: Virtual LUN on slot %d  id0=%llx id1=%llx\n",
+ __func__, lind, lli->lun_id[0], lli->lun_id[1]);
  } else {
  /*
  * If this LUN is visible only from one port, we will put
@@ -898,14 +907,14 @@ static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
  lind = lli->lun_index = cfg->last_lun_index[chan];
  writeq_be(lli->lun_id[chan], &agm->fc_port[chan][lind]);
  cfg->last_lun_index[chan]--;
- pr_debug("%s: Virtual LUN on slot %d  chan=%d, id=%llx\n",
- __func__, lind, chan, lli->lun_id[chan]);
+ dev_dbg(dev, "%s: Virtual LUN on slot %d  chan=%d id=%llx\n",
+ __func__, lind, chan, lli->lun_id[chan]);
  }
 
  lli->in_table = true;
 out:
  mutex_unlock(&global.mutex);
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 }
 
@@ -923,7 +932,7 @@ static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
  */
 int cxlflash_disk_virtual_open(struct scsi_device *sdev, void *arg)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
  struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = sdev->hostdata;
  struct glun_info *gli = lli->parent;
@@ -942,14 +951,14 @@ int cxlflash_disk_virtual_open(struct scsi_device *sdev, void *arg)
  struct ctx_info *ctxi = NULL;
  struct sisl_rht_entry *rhte = NULL;
 
- pr_debug("%s: ctxid=%llu ls=0x%llx\n", __func__, ctxid, lun_size);
+ dev_dbg(dev, "%s: ctxid=%llu ls=%llu\n", __func__, ctxid, lun_size);
 
  /* Setup the LUNs block allocator on first call */
  mutex_lock(&gli->mutex);
  if (gli->mode == MODE_NONE) {
  rc = init_vlun(lli);
  if (rc) {
- dev_err(dev, "%s: call to init_vlun failed rc=%d!\n",
+ dev_err(dev, "%s: init_vlun failed rc=%d\n",
  __func__, rc);
  rc = -ENOMEM;
  goto err0;
@@ -958,29 +967,28 @@ int cxlflash_disk_virtual_open(struct scsi_device *sdev, void *arg)
 
  rc = cxlflash_lun_attach(gli, MODE_VIRTUAL, true);
  if (unlikely(rc)) {
- dev_err(dev, "%s: Failed to attach to LUN! (VIRTUAL)\n",
- __func__);
+ dev_err(dev, "%s: Failed attach to LUN (VIRTUAL)\n", __func__);
  goto err0;
  }
  mutex_unlock(&gli->mutex);
 
  rc = init_luntable(cfg, lli);
  if (rc) {
- dev_err(dev, "%s: call to init_luntable failed rc=%d!\n",
- __func__, rc);
+ dev_err(dev, "%s: init_luntable failed rc=%d\n", __func__, rc);
  goto err1;
  }
 
  ctxi = get_context(cfg, rctxid, lli, 0);
  if (unlikely(!ctxi)) {
- dev_err(dev, "%s: Bad context! (%llu)\n", __func__, ctxid);
+ dev_err(dev, "%s: Bad context ctxid=%llu\n", __func__, ctxid);
  rc = -EINVAL;
  goto err1;
  }
 
  rhte = rhte_checkout(ctxi, lli);
  if (unlikely(!rhte)) {
- dev_err(dev, "%s: too many opens for this context\n", __func__);
+ dev_err(dev, "%s: too many opens ctxid=%llu\n",
+ __func__, ctxid);
  rc = -EMFILE; /* too many opens  */
  goto err1;
  }
@@ -996,7 +1004,7 @@ int cxlflash_disk_virtual_open(struct scsi_device *sdev, void *arg)
  resize.rsrc_handle = rsrc_handle;
  rc = _cxlflash_vlun_resize(sdev, ctxi, &resize);
  if (rc) {
- dev_err(dev, "%s: resize failed rc %d\n", __func__, rc);
+ dev_err(dev, "%s: resize failed rc=%d\n", __func__, rc);
  goto err2;
  }
  last_lba = resize.last_lba;
@@ -1013,8 +1021,8 @@ int cxlflash_disk_virtual_open(struct scsi_device *sdev, void *arg)
 out:
  if (likely(ctxi))
  put_context(ctxi);
- pr_debug("%s: returning handle 0x%llx rc=%d llba %lld\n",
- __func__, rsrc_handle, rc, last_lba);
+ dev_dbg(dev, "%s: returning handle=%llu rc=%d llba=%llu\n",
+ __func__, rsrc_handle, rc, last_lba);
  return rc;
 
 err2:
@@ -1047,6 +1055,8 @@ static int clone_lxt(struct afu *afu,
      struct sisl_rht_entry *rhte,
      struct sisl_rht_entry *rhte_src)
 {
+ struct cxlflash_cfg *cfg = afu->parent;
+ struct device *dev = &cfg->dev->dev;
  struct sisl_lxt_entry *lxt;
  u32 ngrps;
  u64 aun; /* chunk# allocated by block allocator */
@@ -1101,7 +1111,7 @@ static int clone_lxt(struct afu *afu,
 
  cxlflash_afu_sync(afu, ctxid, rhndl, AFU_LW_SYNC);
 
- pr_debug("%s: returning\n", __func__);
+ dev_dbg(dev, "%s: returning\n", __func__);
  return 0;
 }
 
@@ -1120,7 +1130,8 @@ static int clone_lxt(struct afu *afu,
 int cxlflash_disk_clone(struct scsi_device *sdev,
  struct dk_cxlflash_clone *clone)
 {
- struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
+ struct cxlflash_cfg *cfg = shost_priv(sdev->host);
+ struct device *dev = &cfg->dev->dev;
  struct llun_info *lli = sdev->hostdata;
  struct glun_info *gli = lli->parent;
  struct blka *blka = &gli->blka;
@@ -1140,8 +1151,8 @@ int cxlflash_disk_clone(struct scsi_device *sdev,
  bool found;
  LIST_HEAD(sidecar);
 
- pr_debug("%s: ctxid_src=%llu ctxid_dst=%llu\n",
- __func__, ctxid_src, ctxid_dst);
+ dev_dbg(dev, "%s: ctxid_src=%llu ctxid_dst=%llu\n",
+ __func__, ctxid_src, ctxid_dst);
 
  /* Do not clone yourself */
  if (unlikely(rctxid_src == rctxid_dst)) {
@@ -1151,16 +1162,16 @@ int cxlflash_disk_clone(struct scsi_device *sdev,
 
  if (unlikely(gli->mode != MODE_VIRTUAL)) {
  rc = -EINVAL;
- pr_debug("%s: Clone not supported on physical LUNs! (%d)\n",
- __func__, gli->mode);
+ dev_dbg(dev, "%s: Only supported on virtual LUNs mode=%u\n",
+ __func__, gli->mode);
  goto out;
  }
 
  ctxi_src = get_context(cfg, rctxid_src, lli, CTX_CTRL_CLONE);
  ctxi_dst = get_context(cfg, rctxid_dst, lli, 0);
  if (unlikely(!ctxi_src || !ctxi_dst)) {
- pr_debug("%s: Bad context! (%llu,%llu)\n", __func__,
- ctxid_src, ctxid_dst);
+ dev_dbg(dev, "%s: Bad context ctxid_src=%llu ctxid_dst=%llu\n",
+ __func__, ctxid_src, ctxid_dst);
  rc = -EINVAL;
  goto out;
  }
@@ -1185,8 +1196,8 @@ int cxlflash_disk_clone(struct scsi_device *sdev,
  lun_access_dst = kzalloc(sizeof(*lun_access_dst),
  GFP_KERNEL);
  if (unlikely(!lun_access_dst)) {
- pr_err("%s: Unable to allocate lun_access!\n",
-       __func__);
+ dev_err(dev, "%s: lun_access allocation fail\n",
+ __func__);
  rc = -ENOMEM;
  goto out;
  }
@@ -1197,7 +1208,7 @@ int cxlflash_disk_clone(struct scsi_device *sdev,
  }
 
  if (unlikely(!ctxi_src->rht_out)) {
- pr_debug("%s: Nothing to clone!\n", __func__);
+ dev_dbg(dev, "%s: Nothing to clone\n", __func__);
  goto out_success;
  }
 
@@ -1256,7 +1267,7 @@ int cxlflash_disk_clone(struct scsi_device *sdev,
  put_context(ctxi_src);
  if (ctxi_dst)
  put_context(ctxi_dst);
- pr_debug("%s: returning rc=%d\n", __func__, rc);
+ dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 
 err:
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 04/44] scsi: cxlflash: Cancel scheduled workers before stopping AFU

Victor Aoqui
In reply to this post by Victor Aoqui
From: Uma Krishnan <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

When processing an AFU asynchronous interrupt, if the action results in an
operation that requires off level processing (a link reset for example),
the worker thread is scheduled. In the meantime a reset event (i.e.: EEH)
could unmap the AFU to recover. This results in an Oops when the worker
thread tries to access the AFU mapping.

[c000000f17e03b90] d000000007cd5978 cxlflash_worker_thread+0x268/0x550
[c000000f17e03c40] c00000000011883c process_one_work+0x1dc/0x680
[c000000f17e03ce0] c000000000118e80 worker_thread+0x1a0/0x520
[c000000f17e03d80] c000000000126174 kthread+0xf4/0x100
[c000000f17e03e30] c00000000000a47c ret_from_kernel_thread+0x5c/0xe0

In an effort to avoid this, a mapcount was introduced in
commit b45cdbaf9f7f ("cxlflash: Resolve oops in wait_port_offline")
but due to the race condition described above, this solution is incomplete.

In order to fully resolve this problem and to simplify things, this commit
removes the mapcount solution. Instead, the scheduled worker thread is
cancelled after interrupts have been disabled and prior to the mapping
being freed.

Fixes: b45cdbaf9f7f ("cxlflash: Resolve oops in wait_port_offline")
Signed-off-by: Uma Krishnan <[hidden email]>
Acked-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 0df5bef739601f18bffc0d256ae451f239a826bd)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/common.h |  2 --
 drivers/scsi/cxlflash/main.c   | 34 ++++++----------------------------
 2 files changed, 6 insertions(+), 30 deletions(-)

diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h
index dee865735ac0..d11dcc59ff46 100644
--- a/drivers/scsi/cxlflash/common.h
+++ b/drivers/scsi/cxlflash/common.h
@@ -174,8 +174,6 @@ struct afu {
  struct sisl_host_map __iomem *host_map; /* MC host map */
  struct sisl_ctrl_map __iomem *ctrl_map; /* MC control map */
 
- struct kref mapcount;
-
  ctx_hndl_t ctx_hndl; /* master's context handle */
 
  atomic_t hsq_credits;
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index ab38bca5df2b..7069639e92bc 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -419,16 +419,6 @@ static int send_tmf(struct afu *afu, struct scsi_cmnd *scp, u64 tmfcmd)
  return rc;
 }
 
-static void afu_unmap(struct kref *ref)
-{
- struct afu *afu = container_of(ref, struct afu, mapcount);
-
- if (likely(afu->afu_map)) {
- cxl_psa_unmap((void __iomem *)afu->afu_map);
- afu->afu_map = NULL;
- }
-}
-
 /**
  * cxlflash_driver_info() - information handler for this host driver
  * @host: SCSI host associated with device.
@@ -459,7 +449,6 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
  ulong lock_flags;
  int nseg = 0;
  int rc = 0;
- int kref_got = 0;
 
  dev_dbg_ratelimited(dev, "%s: (scp=%p) %d/%d/%d/%llu "
     "cdb=(%08x-%08x-%08x-%08x)\n",
@@ -497,9 +486,6 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
  break;
  }
 
- kref_get(&cfg->afu->mapcount);
- kref_got = 1;
-
  if (likely(sg)) {
  nseg = scsi_dma_map(scp);
  if (unlikely(nseg < 0)) {
@@ -530,8 +516,6 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
  if (unlikely(rc))
  scsi_dma_unmap(scp);
 out:
- if (kref_got)
- kref_put(&afu->mapcount, afu_unmap);
  return rc;
 }
 
@@ -569,13 +553,15 @@ static void free_mem(struct cxlflash_cfg *cfg)
  *
  * Safe to call with AFU in a partially allocated/initialized state.
  *
- * Waits for any active internal AFU commands to timeout and then unmaps
- * the MMIO space.
+ * Cancels scheduled worker threads, waits for any active internal AFU
+ * commands to timeout and then unmaps the MMIO space.
  */
 static void stop_afu(struct cxlflash_cfg *cfg)
 {
  struct afu *afu = cfg->afu;
 
+ cancel_work_sync(&cfg->work_q);
+
  if (likely(afu)) {
  while (atomic_read(&afu->cmds_active))
  ssleep(1);
@@ -583,7 +569,6 @@ static void stop_afu(struct cxlflash_cfg *cfg)
  cxl_psa_unmap((void __iomem *)afu->afu_map);
  afu->afu_map = NULL;
  }
- kref_put(&afu->mapcount, afu_unmap);
  }
 }
 
@@ -767,7 +752,6 @@ static void cxlflash_remove(struct pci_dev *pdev)
  scsi_remove_host(cfg->host);
  /* fall through */
  case INIT_STATE_AFU:
- cancel_work_sync(&cfg->work_q);
  term_afu(cfg);
  case INIT_STATE_PCI:
  pci_disable_device(pdev);
@@ -1277,7 +1261,6 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
  __func__, port);
  cfg->lr_state = LINK_RESET_REQUIRED;
  cfg->lr_port = port;
- kref_get(&cfg->afu->mapcount);
  schedule_work(&cfg->work_q);
  }
 
@@ -1298,7 +1281,6 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
 
  if (info->action & SCAN_HOST) {
  atomic_inc(&cfg->scan_host_needed);
- kref_get(&cfg->afu->mapcount);
  schedule_work(&cfg->work_q);
  }
  }
@@ -1704,7 +1686,6 @@ static int init_afu(struct cxlflash_cfg *cfg)
  rc = -ENOMEM;
  goto err1;
  }
- kref_init(&afu->mapcount);
 
  /* No byte reverse on reading afu_version or string will be backwards */
  reg = readq(&afu->afu_map->global.regs.afu_version);
@@ -1716,7 +1697,7 @@ static int init_afu(struct cxlflash_cfg *cfg)
  "interface version %016llx\n", afu->version,
        afu->interface_version);
  rc = -EINVAL;
- goto err2;
+ goto err1;
  }
 
  if (afu_is_sq_cmd_mode(afu)) {
@@ -1733,7 +1714,7 @@ static int init_afu(struct cxlflash_cfg *cfg)
  rc = start_afu(cfg);
  if (rc) {
  dev_err(dev, "%s: start_afu failed, rc=%d\n", __func__, rc);
- goto err2;
+ goto err1;
  }
 
  afu_err_intr_init(cfg->afu);
@@ -1746,8 +1727,6 @@ static int init_afu(struct cxlflash_cfg *cfg)
  dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
 
-err2:
- kref_put(&afu->mapcount, afu_unmap);
 err1:
  term_intr(cfg, UNMAP_THREE);
  term_mc(cfg);
@@ -2341,7 +2320,6 @@ static void cxlflash_worker_thread(struct work_struct *work)
 
  if (atomic_dec_if_positive(&cfg->scan_host_needed) >= 0)
  scsi_scan_host(cfg->host);
- kref_put(&afu->mapcount, afu_unmap);
 }
 
 /**
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 05/44] scsi: cxlflash: Enable PCI device ID for future IBM CXL Flash AFU

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

Add support for a future IBM Coherent Accelerator (CXL) flash AFU with
an ID of 0x0624.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 943445200b049d5179b95297e5372d399c8ab0e2)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/main.c | 4 ++++
 drivers/scsi/cxlflash/main.h | 1 +
 2 files changed, 5 insertions(+)

diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 7069639e92bc..3061d8045382 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -2259,6 +2259,8 @@ static struct dev_dependent_vals dev_corsa_vals = { CXLFLASH_MAX_SECTORS,
  0ULL };
 static struct dev_dependent_vals dev_flash_gt_vals = { CXLFLASH_MAX_SECTORS,
  CXLFLASH_NOTIFY_SHUTDOWN };
+static struct dev_dependent_vals dev_briard_vals = { CXLFLASH_MAX_SECTORS,
+ CXLFLASH_NOTIFY_SHUTDOWN };
 
 /*
  * PCI device binding table
@@ -2268,6 +2270,8 @@ static struct pci_device_id cxlflash_pci_table[] = {
  PCI_ANY_ID, PCI_ANY_ID, 0, 0, (kernel_ulong_t)&dev_corsa_vals},
  {PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_FLASH_GT,
  PCI_ANY_ID, PCI_ANY_ID, 0, 0, (kernel_ulong_t)&dev_flash_gt_vals},
+ {PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_BRIARD,
+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, (kernel_ulong_t)&dev_briard_vals},
  {}
 };
 
diff --git a/drivers/scsi/cxlflash/main.h b/drivers/scsi/cxlflash/main.h
index e43545c86bcf..0be2261e6312 100644
--- a/drivers/scsi/cxlflash/main.h
+++ b/drivers/scsi/cxlflash/main.h
@@ -25,6 +25,7 @@
 
 #define PCI_DEVICE_ID_IBM_CORSA 0x04F0
 #define PCI_DEVICE_ID_IBM_FLASH_GT 0x0600
+#define PCI_DEVICE_ID_IBM_BRIARD 0x0624
 
 /* Since there is only one target, make it 0 */
 #define CXLFLASH_TARGET 0
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 06/44] scsi: cxlflash: Separate RRQ processing from the RRQ interrupt handler

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

In order to support processing the HRRQ by other means (e.g. polling), the
processing portion of the current RRQ interrupt handler needs to be broken out
into a separate routine. This will allow RRQ processing from places other than
the RRQ hardware interrupt handler.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 76a6ebbeef26b004c36a0c8ee0496bae5428fc31)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/main.c | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 3061d8045382..30c09593c122 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -1155,19 +1155,18 @@ static irqreturn_t cxlflash_sync_err_irq(int irq, void *data)
 }
 
 /**
- * cxlflash_rrq_irq() - interrupt handler for read-response queue (normal path)
- * @irq: Interrupt number.
- * @data: Private data provided at interrupt registration, the AFU.
+ * process_hrrq() - process the read-response queue
+ * @afu: AFU associated with the host.
  *
- * Return: Always return IRQ_HANDLED.
+ * Return: The number of entries processed.
  */
-static irqreturn_t cxlflash_rrq_irq(int irq, void *data)
+static int process_hrrq(struct afu *afu)
 {
- struct afu *afu = (struct afu *)data;
  struct afu_cmd *cmd;
  struct sisl_ioasa *ioasa;
  struct sisl_ioarcb *ioarcb;
  bool toggle = afu->toggle;
+ int num_hrrq = 0;
  u64 entry,
     *hrrq_start = afu->hrrq_start,
     *hrrq_end = afu->hrrq_end,
@@ -1201,11 +1200,27 @@ static irqreturn_t cxlflash_rrq_irq(int irq, void *data)
  }
 
  atomic_inc(&afu->hsq_credits);
+ num_hrrq++;
  }
 
  afu->hrrq_curr = hrrq_curr;
  afu->toggle = toggle;
 
+ return num_hrrq;
+}
+
+/**
+ * cxlflash_rrq_irq() - interrupt handler for read-response queue (normal path)
+ * @irq: Interrupt number.
+ * @data: Private data provided at interrupt registration, the AFU.
+ *
+ * Return: Always return IRQ_HANDLED.
+ */
+static irqreturn_t cxlflash_rrq_irq(int irq, void *data)
+{
+ struct afu *afu = (struct afu *)data;
+
+ process_hrrq(afu);
  return IRQ_HANDLED;
 }
 
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 07/44] scsi: cxlflash: Serialize RRQ access and support offlevel processing

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

As further staging to support processing the HRRQ by other means, access to
the HRRQ needs to be serialized by a disabled lock. This will allow safe
access in other non-hardware interrupt contexts. In an effort to minimize the
period where interrupts are disabled, support is added to queue up commands
harvested from the RRQ such that they can be processed with hardware
interrupts enabled. While this doesn't offer any improvement with processing
on a hardware interrupt it will help when IRQ polling is supported and the
command completions can execute on softirq context.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit f918b4a8e6f8bb59c44045f85d10fd9cc7e5a4c0)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/common.h |  2 ++
 drivers/scsi/cxlflash/main.c   | 42 +++++++++++++++++++++++++++++++++++-------
 2 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h
index d11dcc59ff46..9d56b8c797c4 100644
--- a/drivers/scsi/cxlflash/common.h
+++ b/drivers/scsi/cxlflash/common.h
@@ -134,6 +134,7 @@ struct afu_cmd {
  struct afu *parent;
  struct scsi_cmnd *scp;
  struct completion cevent;
+ struct list_head queue;
 
  u8 cmd_tmf:1;
 
@@ -181,6 +182,7 @@ struct afu {
  struct sisl_ioarcb *hsq_start;
  struct sisl_ioarcb *hsq_end;
  struct sisl_ioarcb *hsq_curr;
+ spinlock_t hrrq_slock;
  u64 *hrrq_start;
  u64 *hrrq_end;
  u64 *hrrq_curr;
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 30c09593c122..8c207ba8474b 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -1157,10 +1157,13 @@ static irqreturn_t cxlflash_sync_err_irq(int irq, void *data)
 /**
  * process_hrrq() - process the read-response queue
  * @afu: AFU associated with the host.
+ * @doneq: Queue of commands harvested from the RRQ.
+ *
+ * This routine must be called holding the disabled RRQ spin lock.
  *
  * Return: The number of entries processed.
  */
-static int process_hrrq(struct afu *afu)
+static int process_hrrq(struct afu *afu, struct list_head *doneq)
 {
  struct afu_cmd *cmd;
  struct sisl_ioasa *ioasa;
@@ -1189,7 +1192,7 @@ static int process_hrrq(struct afu *afu)
  cmd = container_of(ioarcb, struct afu_cmd, rcb);
  }
 
- cmd_complete(cmd);
+ list_add_tail(&cmd->queue, doneq);
 
  /* Advance to next entry or wrap and flip the toggle bit */
  if (hrrq_curr < hrrq_end)
@@ -1210,17 +1213,43 @@ static int process_hrrq(struct afu *afu)
 }
 
 /**
+ * process_cmd_doneq() - process a queue of harvested RRQ commands
+ * @doneq: Queue of completed commands.
+ *
+ * Note that upon return the queue can no longer be trusted.
+ */
+static void process_cmd_doneq(struct list_head *doneq)
+{
+ struct afu_cmd *cmd, *tmp;
+
+ WARN_ON(list_empty(doneq));
+
+ list_for_each_entry_safe(cmd, tmp, doneq, queue)
+ cmd_complete(cmd);
+}
+
+/**
  * cxlflash_rrq_irq() - interrupt handler for read-response queue (normal path)
  * @irq: Interrupt number.
  * @data: Private data provided at interrupt registration, the AFU.
  *
- * Return: Always return IRQ_HANDLED.
+ * Return: IRQ_HANDLED or IRQ_NONE when no ready entries found.
  */
 static irqreturn_t cxlflash_rrq_irq(int irq, void *data)
 {
  struct afu *afu = (struct afu *)data;
+ unsigned long hrrq_flags;
+ LIST_HEAD(doneq);
+ int num_entries = 0;
 
- process_hrrq(afu);
+ spin_lock_irqsave(&afu->hrrq_slock, hrrq_flags);
+ num_entries = process_hrrq(afu, &doneq);
+ spin_unlock_irqrestore(&afu->hrrq_slock, hrrq_flags);
+
+ if (num_entries == 0)
+ return IRQ_NONE;
+
+ process_cmd_doneq(&doneq);
  return IRQ_HANDLED;
 }
 
@@ -1540,14 +1569,13 @@ static int start_afu(struct cxlflash_cfg *cfg)
 
  init_pcr(cfg);
 
- /* After an AFU reset, RRQ entries are stale, clear them */
+ /* Initialize RRQ */
  memset(&afu->rrq_entry, 0, sizeof(afu->rrq_entry));
-
- /* Initialize RRQ pointers */
  afu->hrrq_start = &afu->rrq_entry[0];
  afu->hrrq_end = &afu->rrq_entry[NUM_RRQ_ENTRY - 1];
  afu->hrrq_curr = afu->hrrq_start;
  afu->toggle = 1;
+ spin_lock_init(&afu->hrrq_slock);
 
  /* Initialize SQ */
  if (afu_is_sq_cmd_mode(afu)) {
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 08/44] scsi: cxlflash: Implement IRQ polling for RRQ processing

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

Currently, RRQ processing takes place on hardware interrupt context. This can
be a heavy burden in some environments due to the overhead encountered while
completing RRQ entries. In an effort to improve system performance, use the
IRQ polling API to schedule this processing on softirq context.

This function will be disabled by default until starting values can be
established for the hardware supported by this driver.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit cba06e6de4038cd44a3e93a92ad982c372b8a14e)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/common.h |   8 +++
 drivers/scsi/cxlflash/main.c   | 123 +++++++++++++++++++++++++++++++++++++++--
 2 files changed, 127 insertions(+), 4 deletions(-)

diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h
index 9d56b8c797c4..3ff05f15b417 100644
--- a/drivers/scsi/cxlflash/common.h
+++ b/drivers/scsi/cxlflash/common.h
@@ -15,6 +15,7 @@
 #ifndef _CXLFLASH_COMMON_H
 #define _CXLFLASH_COMMON_H
 
+#include <linux/irq_poll.h>
 #include <linux/list.h>
 #include <linux/rwsem.h>
 #include <linux/types.h>
@@ -196,10 +197,17 @@ struct afu {
  char version[16];
  u64 interface_version;
 
+ u32 irqpoll_weight;
+ struct irq_poll irqpoll;
  struct cxlflash_cfg *parent; /* Pointer back to parent cxlflash_cfg */
 
 };
 
+static inline bool afu_is_irqpoll_enabled(struct afu *afu)
+{
+ return !!afu->irqpoll_weight;
+}
+
 static inline bool afu_is_cmd_mode(struct afu *afu, u64 cmd_mode)
 {
  u64 afu_cap = afu->interface_version >> SISL_INTVER_CAP_SHIFT;
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 8c207ba8474b..30d68af87d1d 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -554,7 +554,7 @@ static void free_mem(struct cxlflash_cfg *cfg)
  * Safe to call with AFU in a partially allocated/initialized state.
  *
  * Cancels scheduled worker threads, waits for any active internal AFU
- * commands to timeout and then unmaps the MMIO space.
+ * commands to timeout, disables IRQ polling and then unmaps the MMIO space.
  */
 static void stop_afu(struct cxlflash_cfg *cfg)
 {
@@ -565,6 +565,8 @@ static void stop_afu(struct cxlflash_cfg *cfg)
  if (likely(afu)) {
  while (atomic_read(&afu->cmds_active))
  ssleep(1);
+ if (afu_is_irqpoll_enabled(afu))
+ irq_poll_disable(&afu->irqpoll);
  if (likely(afu->afu_map)) {
  cxl_psa_unmap((void __iomem *)afu->afu_map);
  afu->afu_map = NULL;
@@ -1158,12 +1160,13 @@ static irqreturn_t cxlflash_sync_err_irq(int irq, void *data)
  * process_hrrq() - process the read-response queue
  * @afu: AFU associated with the host.
  * @doneq: Queue of commands harvested from the RRQ.
+ * @budget: Threshold of RRQ entries to process.
  *
  * This routine must be called holding the disabled RRQ spin lock.
  *
  * Return: The number of entries processed.
  */
-static int process_hrrq(struct afu *afu, struct list_head *doneq)
+static int process_hrrq(struct afu *afu, struct list_head *doneq, int budget)
 {
  struct afu_cmd *cmd;
  struct sisl_ioasa *ioasa;
@@ -1175,7 +1178,7 @@ static int process_hrrq(struct afu *afu, struct list_head *doneq)
     *hrrq_end = afu->hrrq_end,
     *hrrq_curr = afu->hrrq_curr;
 
- /* Process however many RRQ entries that are ready */
+ /* Process ready RRQ entries up to the specified budget (if any) */
  while (true) {
  entry = *hrrq_curr;
 
@@ -1204,6 +1207,9 @@ static int process_hrrq(struct afu *afu, struct list_head *doneq)
 
  atomic_inc(&afu->hsq_credits);
  num_hrrq++;
+
+ if (budget > 0 && num_hrrq >= budget)
+ break;
  }
 
  afu->hrrq_curr = hrrq_curr;
@@ -1229,6 +1235,32 @@ static void process_cmd_doneq(struct list_head *doneq)
 }
 
 /**
+ * cxlflash_irqpoll() - process a queue of harvested RRQ commands
+ * @irqpoll: IRQ poll structure associated with queue to poll.
+ * @budget: Threshold of RRQ entries to process per poll.
+ *
+ * Return: The number of entries processed.
+ */
+static int cxlflash_irqpoll(struct irq_poll *irqpoll, int budget)
+{
+ struct afu *afu = container_of(irqpoll, struct afu, irqpoll);
+ unsigned long hrrq_flags;
+ LIST_HEAD(doneq);
+ int num_entries = 0;
+
+ spin_lock_irqsave(&afu->hrrq_slock, hrrq_flags);
+
+ num_entries = process_hrrq(afu, &doneq, budget);
+ if (num_entries < budget)
+ irq_poll_complete(irqpoll);
+
+ spin_unlock_irqrestore(&afu->hrrq_slock, hrrq_flags);
+
+ process_cmd_doneq(&doneq);
+ return num_entries;
+}
+
+/**
  * cxlflash_rrq_irq() - interrupt handler for read-response queue (normal path)
  * @irq: Interrupt number.
  * @data: Private data provided at interrupt registration, the AFU.
@@ -1243,7 +1275,14 @@ static irqreturn_t cxlflash_rrq_irq(int irq, void *data)
  int num_entries = 0;
 
  spin_lock_irqsave(&afu->hrrq_slock, hrrq_flags);
- num_entries = process_hrrq(afu, &doneq);
+
+ if (afu_is_irqpoll_enabled(afu)) {
+ irq_poll_sched(&afu->irqpoll);
+ spin_unlock_irqrestore(&afu->hrrq_slock, hrrq_flags);
+ return IRQ_HANDLED;
+ }
+
+ num_entries = process_hrrq(afu, &doneq, -1);
  spin_unlock_irqrestore(&afu->hrrq_slock, hrrq_flags);
 
  if (num_entries == 0)
@@ -1588,6 +1627,11 @@ static int start_afu(struct cxlflash_cfg *cfg)
  atomic_set(&afu->hsq_credits, NUM_SQ_ENTRY - 1);
  }
 
+ /* Initialize IRQ poll */
+ if (afu_is_irqpoll_enabled(afu))
+ irq_poll_init(&afu->irqpoll, afu->irqpoll_weight,
+      cxlflash_irqpoll);
+
  rc = init_global(cfg);
 
  dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
@@ -2225,6 +2269,75 @@ static ssize_t port1_lun_table_show(struct device *dev,
 }
 
 /**
+ * irqpoll_weight_show() - presents the current IRQ poll weight for the host
+ * @dev: Generic device associated with the host.
+ * @attr: Device attribute representing the IRQ poll weight.
+ * @buf: Buffer of length PAGE_SIZE to report back the current IRQ poll
+ * weight in ASCII.
+ *
+ * An IRQ poll weight of 0 indicates polling is disabled.
+ *
+ * Return: The size of the ASCII string returned in @buf.
+ */
+static ssize_t irqpoll_weight_show(struct device *dev,
+   struct device_attribute *attr, char *buf)
+{
+ struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
+ struct afu *afu = cfg->afu;
+
+ return scnprintf(buf, PAGE_SIZE, "%u\n", afu->irqpoll_weight);
+}
+
+/**
+ * irqpoll_weight_store() - sets the current IRQ poll weight for the host
+ * @dev: Generic device associated with the host.
+ * @attr: Device attribute representing the IRQ poll weight.
+ * @buf: Buffer of length PAGE_SIZE containing the desired IRQ poll
+ * weight in ASCII.
+ * @count: Length of data resizing in @buf.
+ *
+ * An IRQ poll weight of 0 indicates polling is disabled.
+ *
+ * Return: The size of the ASCII string returned in @buf.
+ */
+static ssize_t irqpoll_weight_store(struct device *dev,
+    struct device_attribute *attr,
+    const char *buf, size_t count)
+{
+ struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
+ struct device *cfgdev = &cfg->dev->dev;
+ struct afu *afu = cfg->afu;
+ u32 weight;
+ int rc;
+
+ rc = kstrtouint(buf, 10, &weight);
+ if (rc)
+ return -EINVAL;
+
+ if (weight > 256) {
+ dev_info(cfgdev,
+ "Invalid IRQ poll weight. It must be 256 or less.\n");
+ return -EINVAL;
+ }
+
+ if (weight == afu->irqpoll_weight) {
+ dev_info(cfgdev,
+ "Current IRQ poll weight has the same weight.\n");
+ return -EINVAL;
+ }
+
+ if (afu_is_irqpoll_enabled(afu))
+ irq_poll_disable(&afu->irqpoll);
+
+ afu->irqpoll_weight = weight;
+
+ if (weight > 0)
+ irq_poll_init(&afu->irqpoll, weight, cxlflash_irqpoll);
+
+ return count;
+}
+
+/**
  * mode_show() - presents the current mode of the device
  * @dev: Generic device associated with the device.
  * @attr: Device attribute representing the device mode.
@@ -2250,6 +2363,7 @@ static DEVICE_ATTR_RW(lun_mode);
 static DEVICE_ATTR_RO(ioctl_version);
 static DEVICE_ATTR_RO(port0_lun_table);
 static DEVICE_ATTR_RO(port1_lun_table);
+static DEVICE_ATTR_RW(irqpoll_weight);
 
 static struct device_attribute *cxlflash_host_attrs[] = {
  &dev_attr_port0,
@@ -2258,6 +2372,7 @@ static struct device_attribute *cxlflash_host_attrs[] = {
  &dev_attr_ioctl_version,
  &dev_attr_port0_lun_table,
  &dev_attr_port1_lun_table,
+ &dev_attr_irqpoll_weight,
  NULL
 };
 
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 09/44] scsi: cxlflash: Update sysfs helper routines to pass config structure

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

As staging for future function, pass the config pointer instead of the AFU
pointer for port-related sysfs helper routines.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 3b225cd32a05b627a6ca366f364a824beaabecc5)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/main.c | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 30d68af87d1d..157d806c97fc 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -2058,13 +2058,16 @@ static int cxlflash_change_queue_depth(struct scsi_device *sdev, int qdepth)
 /**
  * cxlflash_show_port_status() - queries and presents the current port status
  * @port: Desired port for status reporting.
- * @afu: AFU owning the specified port.
+ * @cfg: Internal structure associated with the host.
  * @buf: Buffer of length PAGE_SIZE to report back port status in ASCII.
  *
  * Return: The size of the ASCII string returned in @buf.
  */
-static ssize_t cxlflash_show_port_status(u32 port, struct afu *afu, char *buf)
+static ssize_t cxlflash_show_port_status(u32 port,
+ struct cxlflash_cfg *cfg,
+ char *buf)
 {
+ struct afu *afu = cfg->afu;
  char *disp_status;
  u64 status;
  __be64 __iomem *fc_regs;
@@ -2099,9 +2102,8 @@ static ssize_t port0_show(struct device *dev,
   char *buf)
 {
  struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
- struct afu *afu = cfg->afu;
 
- return cxlflash_show_port_status(0, afu, buf);
+ return cxlflash_show_port_status(0, cfg, buf);
 }
 
 /**
@@ -2117,9 +2119,8 @@ static ssize_t port1_show(struct device *dev,
   char *buf)
 {
  struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
- struct afu *afu = cfg->afu;
 
- return cxlflash_show_port_status(1, afu, buf);
+ return cxlflash_show_port_status(1, cfg, buf);
 }
 
 /**
@@ -2208,15 +2209,16 @@ static ssize_t ioctl_version_show(struct device *dev,
 /**
  * cxlflash_show_port_lun_table() - queries and presents the port LUN table
  * @port: Desired port for status reporting.
- * @afu: AFU owning the specified port.
+ * @cfg: Internal structure associated with the host.
  * @buf: Buffer of length PAGE_SIZE to report back port status in ASCII.
  *
  * Return: The size of the ASCII string returned in @buf.
  */
 static ssize_t cxlflash_show_port_lun_table(u32 port,
-    struct afu *afu,
+    struct cxlflash_cfg *cfg,
     char *buf)
 {
+ struct afu *afu = cfg->afu;
  int i;
  ssize_t bytes = 0;
  __be64 __iomem *fc_port;
@@ -2245,9 +2247,8 @@ static ssize_t port0_lun_table_show(struct device *dev,
     char *buf)
 {
  struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
- struct afu *afu = cfg->afu;
 
- return cxlflash_show_port_lun_table(0, afu, buf);
+ return cxlflash_show_port_lun_table(0, cfg, buf);
 }
 
 /**
@@ -2263,9 +2264,8 @@ static ssize_t port1_lun_table_show(struct device *dev,
     char *buf)
 {
  struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
- struct afu *afu = cfg->afu;
 
- return cxlflash_show_port_lun_table(1, afu, buf);
+ return cxlflash_show_port_lun_table(1, cfg, buf);
 }
 
 /**
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 10/44] scsi: cxlflash: Support dynamic number of FC ports

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

Transition from a static number of FC ports to a value that is derived during
probe. For now, a static value is used but this will later be based on the
type of card being configured.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 78ae028e823701148e4915759459ee79597ea8ec)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/common.h    |  7 ++--
 drivers/scsi/cxlflash/main.c      | 71 ++++++++++++++++++++++++---------------
 drivers/scsi/cxlflash/main.h      |  2 --
 drivers/scsi/cxlflash/sislite.h   |  1 +
 drivers/scsi/cxlflash/superpipe.h |  2 +-
 5 files changed, 51 insertions(+), 32 deletions(-)

diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h
index 3ff05f15b417..6a04867a0eec 100644
--- a/drivers/scsi/cxlflash/common.h
+++ b/drivers/scsi/cxlflash/common.h
@@ -25,7 +25,9 @@
 
 extern const struct file_operations cxlflash_cxl_fops;
 
-#define MAX_CONTEXT  CXLFLASH_MAX_CONTEXT       /* num contexts per afu */
+#define MAX_CONTEXT CXLFLASH_MAX_CONTEXT /* num contexts per afu */
+#define NUM_FC_PORTS CXLFLASH_NUM_FC_PORTS /* ports per AFU */
+#define MAX_FC_PORTS CXLFLASH_MAX_FC_PORTS /* ports per AFU */
 
 #define CXLFLASH_BLOCK_SIZE 4096 /* 4K blocks */
 #define CXLFLASH_MAX_XFER_SIZE 16777216 /* 16MB transfer */
@@ -98,6 +100,7 @@ struct cxlflash_cfg {
  struct pci_dev *dev;
  struct pci_device_id *dev_id;
  struct Scsi_Host *host;
+ int num_fc_ports;
 
  ulong cxlflash_regs_pci;
 
@@ -118,7 +121,7 @@ struct cxlflash_cfg {
  struct file_operations cxl_fops;
 
  /* Parameters that are LUN table related */
- int last_lun_index[CXLFLASH_NUM_FC_PORTS];
+ int last_lun_index[MAX_FC_PORTS];
  int promote_lun_index;
  struct list_head lluns; /* list of llun_info structs */
 
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 157d806c97fc..3f9c8690af0d 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -689,7 +689,7 @@ static void notify_shutdown(struct cxlflash_cfg *cfg, bool wait)
  global = &afu->afu_map->global;
 
  /* Notify AFU */
- for (i = 0; i < NUM_FC_PORTS; i++) {
+ for (i = 0; i < cfg->num_fc_ports; i++) {
  reg = readq_be(&global->fc_regs[i][FC_CONFIG2 / 8]);
  reg |= SISL_FC_SHUTDOWN_NORMAL;
  writeq_be(reg, &global->fc_regs[i][FC_CONFIG2 / 8]);
@@ -699,7 +699,7 @@ static void notify_shutdown(struct cxlflash_cfg *cfg, bool wait)
  return;
 
  /* Wait up to 1.5 seconds for shutdown processing to complete */
- for (i = 0; i < NUM_FC_PORTS; i++) {
+ for (i = 0; i < cfg->num_fc_ports; i++) {
  retry_cnt = 0;
  while (true) {
  status = readq_be(&global->fc_regs[i][FC_STATUS / 8]);
@@ -1072,6 +1072,7 @@ static const struct asyc_intr_info *find_ainfo(u64 status)
  */
 static void afu_err_intr_init(struct afu *afu)
 {
+ struct cxlflash_cfg *cfg = afu->parent;
  int i;
  u64 reg;
 
@@ -1107,7 +1108,7 @@ static void afu_err_intr_init(struct afu *afu)
  writeq_be(reg, &afu->afu_map->global.fc_regs[0][FC_CONFIG2 / 8]);
 
  /* now clear FC errors */
- for (i = 0; i < NUM_FC_PORTS; i++) {
+ for (i = 0; i < cfg->num_fc_ports; i++) {
  writeq_be(0xFFFFFFFFU,
   &afu->afu_map->global.fc_regs[i][FC_ERROR / 8]);
  writeq_be(0, &afu->afu_map->global.fc_regs[i][FC_ERRCAP / 8]);
@@ -1394,7 +1395,7 @@ static int start_context(struct cxlflash_cfg *cfg)
 /**
  * read_vpd() - obtains the WWPNs from VPD
  * @cfg: Internal structure associated with the host.
- * @wwpn: Array of size NUM_FC_PORTS to pass back WWPNs
+ * @wwpn: Array of size MAX_FC_PORTS to pass back WWPNs
  *
  * Return: 0 on success, -errno on failure
  */
@@ -1407,7 +1408,7 @@ static int read_vpd(struct cxlflash_cfg *cfg, u64 wwpn[])
  ssize_t vpd_size;
  char vpd_data[CXLFLASH_VPD_LEN];
  char tmp_buf[WWPN_BUF_LEN] = { 0 };
- char *wwpn_vpd_tags[NUM_FC_PORTS] = { "V5", "V6" };
+ char *wwpn_vpd_tags[MAX_FC_PORTS] = { "V5", "V6" };
 
  /* Get the VPD data from the device */
  vpd_size = cxl_read_adapter_vpd(pdev, vpd_data, sizeof(vpd_data));
@@ -1445,7 +1446,7 @@ static int read_vpd(struct cxlflash_cfg *cfg, u64 wwpn[])
  * because the conversion service requires that the ASCII
  * string be terminated.
  */
- for (k = 0; k < NUM_FC_PORTS; k++) {
+ for (k = 0; k < cfg->num_fc_ports; k++) {
  j = ro_size;
  i = ro_start + PCI_VPD_LRDT_TAG_SIZE;
 
@@ -1474,6 +1475,8 @@ static int read_vpd(struct cxlflash_cfg *cfg, u64 wwpn[])
  rc = -ENODEV;
  goto out;
  }
+
+ dev_dbg(dev, "%s: wwpn%d=%016llx\n", __func__, k, wwpn[k]);
  }
 
 out:
@@ -1520,7 +1523,7 @@ static int init_global(struct cxlflash_cfg *cfg)
 {
  struct afu *afu = cfg->afu;
  struct device *dev = &cfg->dev->dev;
- u64 wwpn[NUM_FC_PORTS]; /* wwpn of AFU ports */
+ u64 wwpn[MAX_FC_PORTS]; /* wwpn of AFU ports */
  int i = 0, num_ports = 0;
  int rc = 0;
  u64 reg;
@@ -1531,9 +1534,6 @@ static int init_global(struct cxlflash_cfg *cfg)
  goto out;
  }
 
- dev_dbg(dev, "%s: wwpn0=%016llx wwpn1=%016llx\n",
- __func__, wwpn[0], wwpn[1]);
-
  /* Set up RRQ and SQ in AFU for master issued cmds */
  writeq_be((u64) afu->hrrq_start, &afu->host_map->rrq_start);
  writeq_be((u64) afu->hrrq_end, &afu->host_map->rrq_end);
@@ -1556,10 +1556,10 @@ static int init_global(struct cxlflash_cfg *cfg)
  if (afu->internal_lun) {
  /* Only use port 0 */
  writeq_be(PORT0, &afu->afu_map->global.regs.afu_port_sel);
- num_ports = NUM_FC_PORTS - 1;
+ num_ports = 0;
  } else {
  writeq_be(BOTH_PORTS, &afu->afu_map->global.regs.afu_port_sel);
- num_ports = NUM_FC_PORTS;
+ num_ports = cfg->num_fc_ports;
  }
 
  for (i = 0; i < num_ports; i++) {
@@ -2061,19 +2061,25 @@ static int cxlflash_change_queue_depth(struct scsi_device *sdev, int qdepth)
  * @cfg: Internal structure associated with the host.
  * @buf: Buffer of length PAGE_SIZE to report back port status in ASCII.
  *
- * Return: The size of the ASCII string returned in @buf.
+ * Return: The size of the ASCII string returned in @buf or -EINVAL.
  */
 static ssize_t cxlflash_show_port_status(u32 port,
  struct cxlflash_cfg *cfg,
  char *buf)
 {
+ struct device *dev = &cfg->dev->dev;
  struct afu *afu = cfg->afu;
  char *disp_status;
  u64 status;
  __be64 __iomem *fc_regs;
 
- if (port >= NUM_FC_PORTS)
- return 0;
+ WARN_ON(port >= MAX_FC_PORTS);
+
+ if (port >= cfg->num_fc_ports) {
+ dev_info(dev, "%s: Port %d not supported on this card.\n",
+ __func__, port);
+ return -EINVAL;
+ }
 
  fc_regs = &afu->afu_map->global.fc_regs[port][0];
  status = readq_be(&fc_regs[FC_MTIP_STATUS / 8]);
@@ -2178,12 +2184,13 @@ static ssize_t lun_mode_store(struct device *dev,
 
  /*
  * When configured for internal LUN, there is only one channel,
- * channel number 0, else there will be 2 (default).
+ * channel number 0, else there will be one less than the number
+ * of fc ports for this card.
  */
  if (afu->internal_lun)
  shost->max_channel = 0;
  else
- shost->max_channel = NUM_FC_PORTS - 1;
+ shost->max_channel = cfg->num_fc_ports - 1;
 
  afu_reset(cfg);
  scsi_scan_host(cfg->host);
@@ -2212,19 +2219,25 @@ static ssize_t ioctl_version_show(struct device *dev,
  * @cfg: Internal structure associated with the host.
  * @buf: Buffer of length PAGE_SIZE to report back port status in ASCII.
  *
- * Return: The size of the ASCII string returned in @buf.
+ * Return: The size of the ASCII string returned in @buf or -EINVAL.
  */
 static ssize_t cxlflash_show_port_lun_table(u32 port,
     struct cxlflash_cfg *cfg,
     char *buf)
 {
+ struct device *dev = &cfg->dev->dev;
  struct afu *afu = cfg->afu;
  int i;
  ssize_t bytes = 0;
  __be64 __iomem *fc_port;
 
- if (port >= NUM_FC_PORTS)
- return 0;
+ WARN_ON(port >= MAX_FC_PORTS);
+
+ if (port >= cfg->num_fc_ports) {
+ dev_info(dev, "%s: Port %d not supported on this card.\n",
+ __func__, port);
+ return -EINVAL;
+ }
 
  fc_port = &afu->afu_map->global.fc_port[port][0];
 
@@ -2499,6 +2512,7 @@ static int cxlflash_probe(struct pci_dev *pdev,
  struct device *dev = &pdev->dev;
  struct dev_dependent_vals *ddv;
  int rc = 0;
+ int k;
 
  dev_dbg(&pdev->dev, "%s: Found CXLFLASH with IRQ: %d\n",
  __func__, pdev->irq);
@@ -2531,17 +2545,20 @@ static int cxlflash_probe(struct pci_dev *pdev,
 
  cfg->init_state = INIT_STATE_NONE;
  cfg->dev = pdev;
+ cfg->num_fc_ports = NUM_FC_PORTS;
  cfg->cxl_fops = cxlflash_cxl_fops;
 
  /*
- * The promoted LUNs move to the top of the LUN table. The rest stay
- * on the bottom half. The bottom half grows from the end
- * (index = 255), whereas the top half grows from the beginning
- * (index = 0).
+ * Promoted LUNs move to the top of the LUN table. The rest stay on
+ * the bottom half. The bottom half grows from the end (index = 255),
+ * whereas the top half grows from the beginning (index = 0).
+ *
+ * Initialize the last LUN index for all possible ports.
  */
- cfg->promote_lun_index  = 0;
- cfg->last_lun_index[0] = CXLFLASH_NUM_VLUNS/2 - 1;
- cfg->last_lun_index[1] = CXLFLASH_NUM_VLUNS/2 - 1;
+ cfg->promote_lun_index = 0;
+
+ for (k = 0; k < MAX_FC_PORTS; k++)
+ cfg->last_lun_index[k] = CXLFLASH_NUM_VLUNS/2 - 1;
 
  cfg->dev_id = (struct pci_device_id *)dev_id;
 
diff --git a/drivers/scsi/cxlflash/main.h b/drivers/scsi/cxlflash/main.h
index 0be2261e6312..49657f1f409e 100644
--- a/drivers/scsi/cxlflash/main.h
+++ b/drivers/scsi/cxlflash/main.h
@@ -37,8 +37,6 @@
 
 #define CXLFLASH_PCI_ERROR_RECOVERY_TIMEOUT (120 * HZ)
 
-#define NUM_FC_PORTS CXLFLASH_NUM_FC_PORTS /* ports per AFU */
-
 /* FC defines */
 #define FC_MTIP_CMDCONFIG 0x010
 #define FC_MTIP_STATUS 0x018
diff --git a/drivers/scsi/cxlflash/sislite.h b/drivers/scsi/cxlflash/sislite.h
index a6e48a893fef..0db4bc1f4e23 100644
--- a/drivers/scsi/cxlflash/sislite.h
+++ b/drivers/scsi/cxlflash/sislite.h
@@ -367,6 +367,7 @@ struct sisl_global_regs {
 #define SISL_INTVER_CAP_RESERVED_CMD_MODE_B 0x100000000000ULL
 };
 
+#define CXLFLASH_MAX_FC_PORTS   2
 #define CXLFLASH_NUM_FC_PORTS   2
 #define CXLFLASH_MAX_CONTEXT  512 /* how many contexts per afu */
 #define CXLFLASH_NUM_VLUNS    512
diff --git a/drivers/scsi/cxlflash/superpipe.h b/drivers/scsi/cxlflash/superpipe.h
index 9e62ff304e4b..690ce9c652b2 100644
--- a/drivers/scsi/cxlflash/superpipe.h
+++ b/drivers/scsi/cxlflash/superpipe.h
@@ -59,7 +59,7 @@ struct glun_info {
 
 /* Local (per-adapter) lun_info structure */
 struct llun_info {
- u64 lun_id[CXLFLASH_NUM_FC_PORTS]; /* from REPORT_LUNS */
+ u64 lun_id[MAX_FC_PORTS]; /* from REPORT_LUNS */
  u32 lun_index; /* Index in the LUN table */
  u32 host_no; /* host_no from Scsi_host */
  u32 port_sel; /* What port to use for this LUN */
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 11/44] scsi: cxlflash: Remove port configuration assumptions

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

At present, the cxlflash driver only supports hardware with two FC ports. The
code was initially designed with this assumption and is dependent on having
two FC ports - adding more ports will break logic within the driver.

To mitigate this issue, remove the existing port assumptions and transition
the code to support more than two ports. As a side effect, clarify the
interpretation of the DK_CXLFLASH_ALL_PORTS_ACTIVE flag.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 8fa4f1770d56af6f0a5a862f1fd298a4eeea94f3)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 Documentation/powerpc/cxlflash.txt |  5 +++
 drivers/scsi/cxlflash/common.h     |  4 ++
 drivers/scsi/cxlflash/lunmgt.c     |  4 +-
 drivers/scsi/cxlflash/main.c       | 13 +++---
 drivers/scsi/cxlflash/sislite.h    |  2 +-
 drivers/scsi/cxlflash/superpipe.c  |  2 +-
 drivers/scsi/cxlflash/superpipe.h  |  3 --
 drivers/scsi/cxlflash/vlun.c       | 89 +++++++++++++++++++++++++-------------
 8 files changed, 77 insertions(+), 45 deletions(-)

diff --git a/Documentation/powerpc/cxlflash.txt b/Documentation/powerpc/cxlflash.txt
index 6d9a2ed32cad..66b4496d6619 100644
--- a/Documentation/powerpc/cxlflash.txt
+++ b/Documentation/powerpc/cxlflash.txt
@@ -239,6 +239,11 @@ DK_CXLFLASH_USER_VIRTUAL
     resource handle that is provided is already referencing provisioned
     storage. This is reflected by the last LBA being a non-zero value.
 
+    When a LUN is accessible from more than one port, this ioctl will
+    return with the DK_CXLFLASH_ALL_PORTS_ACTIVE return flag set. This
+    provides the user with a hint that I/O can be retried in the event
+    of an I/O error as the LUN can be reached over multiple paths.
+
 DK_CXLFLASH_VLUN_RESIZE
 -----------------------
     This ioctl is responsible for resizing a previously created virtual
diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h
index 6a04867a0eec..ee23e81994c4 100644
--- a/drivers/scsi/cxlflash/common.h
+++ b/drivers/scsi/cxlflash/common.h
@@ -29,6 +29,10 @@ extern const struct file_operations cxlflash_cxl_fops;
 #define NUM_FC_PORTS CXLFLASH_NUM_FC_PORTS /* ports per AFU */
 #define MAX_FC_PORTS CXLFLASH_MAX_FC_PORTS /* ports per AFU */
 
+#define CHAN2PORTMASK(_x) (1 << (_x)) /* channel to port mask */
+#define PORTMASK2CHAN(_x) (ilog2((_x))) /* port mask to channel */
+#define PORTNUM2CHAN(_x) ((_x) - 1) /* port number to channel */
+
 #define CXLFLASH_BLOCK_SIZE 4096 /* 4K blocks */
 #define CXLFLASH_MAX_XFER_SIZE 16777216 /* 16MB transfer */
 #define CXLFLASH_MAX_SECTORS (CXLFLASH_MAX_XFER_SIZE/512) /* SCSI wants
diff --git a/drivers/scsi/cxlflash/lunmgt.c b/drivers/scsi/cxlflash/lunmgt.c
index 0efed177cc8b..4d232e271af6 100644
--- a/drivers/scsi/cxlflash/lunmgt.c
+++ b/drivers/scsi/cxlflash/lunmgt.c
@@ -252,7 +252,7 @@ int cxlflash_manage_lun(struct scsi_device *sdev,
  * in unpacked, AFU-friendly format, and hang LUN reference in
  * the sdev.
  */
- lli->port_sel |= CHAN2PORT(chan);
+ lli->port_sel |= CHAN2PORTMASK(chan);
  lli->lun_id[chan] = lun_to_lunid(sdev->lun);
  sdev->hostdata = lli;
  } else if (flags & DK_CXLFLASH_MANAGE_LUN_DISABLE_SUPERPIPE) {
@@ -264,7 +264,7 @@ int cxlflash_manage_lun(struct scsi_device *sdev,
  * tracking when no more references exist.
  */
  sdev->hostdata = NULL;
- lli->port_sel &= ~CHAN2PORT(chan);
+ lli->port_sel &= ~CHAN2PORTMASK(chan);
  if (lli->port_sel == 0U)
  lli->in_table = false;
  }
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 3f9c8690af0d..04e1a8effa76 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -365,7 +365,6 @@ static int wait_resp(struct afu *afu, struct afu_cmd *cmd)
  */
 static int send_tmf(struct afu *afu, struct scsi_cmnd *scp, u64 tmfcmd)
 {
- u32 port_sel = scp->device->channel + 1;
  struct cxlflash_cfg *cfg = shost_priv(scp->device->host);
  struct afu_cmd *cmd = sc_to_afucz(scp);
  struct device *dev = &cfg->dev->dev;
@@ -388,7 +387,7 @@ static int send_tmf(struct afu *afu, struct scsi_cmnd *scp, u64 tmfcmd)
 
  cmd->rcb.ctx_id = afu->ctx_hndl;
  cmd->rcb.msi = SISL_MSI_RRQ_UPDATED;
- cmd->rcb.port_sel = port_sel;
+ cmd->rcb.port_sel = CHAN2PORTMASK(scp->device->channel);
  cmd->rcb.lun_id = lun_to_lunid(scp->device->lun);
  cmd->rcb.req_flags = (SISL_REQ_FLAGS_PORT_LUN_ID |
       SISL_REQ_FLAGS_SUP_UNDERRUN |
@@ -444,7 +443,6 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
  struct device *dev = &cfg->dev->dev;
  struct afu_cmd *cmd = sc_to_afucz(scp);
  struct scatterlist *sg = scsi_sglist(scp);
- u32 port_sel = scp->device->channel + 1;
  u16 req_flags = SISL_REQ_FLAGS_SUP_UNDERRUN;
  ulong lock_flags;
  int nseg = 0;
@@ -503,7 +501,7 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
 
  cmd->rcb.ctx_id = afu->ctx_hndl;
  cmd->rcb.msi = SISL_MSI_RRQ_UPDATED;
- cmd->rcb.port_sel = port_sel;
+ cmd->rcb.port_sel = CHAN2PORTMASK(scp->device->channel);
  cmd->rcb.lun_id = lun_to_lunid(scp->device->lun);
 
  if (scp->sc_data_direction == DMA_TO_DEVICE)
@@ -1558,7 +1556,8 @@ static int init_global(struct cxlflash_cfg *cfg)
  writeq_be(PORT0, &afu->afu_map->global.regs.afu_port_sel);
  num_ports = 0;
  } else {
- writeq_be(BOTH_PORTS, &afu->afu_map->global.regs.afu_port_sel);
+ writeq_be(PORT_MASK(cfg->num_fc_ports),
+  &afu->afu_map->global.regs.afu_port_sel);
  num_ports = cfg->num_fc_ports;
  }
 
@@ -2190,7 +2189,7 @@ static ssize_t lun_mode_store(struct device *dev,
  if (afu->internal_lun)
  shost->max_channel = 0;
  else
- shost->max_channel = cfg->num_fc_ports - 1;
+ shost->max_channel = PORTNUM2CHAN(cfg->num_fc_ports);
 
  afu_reset(cfg);
  scsi_scan_host(cfg->host);
@@ -2529,7 +2528,7 @@ static int cxlflash_probe(struct pci_dev *pdev,
 
  host->max_id = CXLFLASH_MAX_NUM_TARGETS_PER_BUS;
  host->max_lun = CXLFLASH_MAX_NUM_LUNS_PER_TARGET;
- host->max_channel = NUM_FC_PORTS - 1;
+ host->max_channel = PORTNUM2CHAN(NUM_FC_PORTS);
  host->unique_id = host->host_no;
  host->max_cmd_len = CXLFLASH_MAX_CDB_LEN;
 
diff --git a/drivers/scsi/cxlflash/sislite.h b/drivers/scsi/cxlflash/sislite.h
index 0db4bc1f4e23..f26f41be5efb 100644
--- a/drivers/scsi/cxlflash/sislite.h
+++ b/drivers/scsi/cxlflash/sislite.h
@@ -479,7 +479,7 @@ struct sisl_rht_entry_f1 {
 
 #define PORT0  0x01U
 #define PORT1  0x02U
-#define BOTH_PORTS    (PORT0 | PORT1)
+#define PORT_MASK(_n) ((1 << (_n)) - 1)
 
 /* AFU Sync Mode byte */
 #define AFU_LW_SYNC 0x0U
diff --git a/drivers/scsi/cxlflash/superpipe.c b/drivers/scsi/cxlflash/superpipe.c
index 90869cee2b20..488330ffdf02 100644
--- a/drivers/scsi/cxlflash/superpipe.c
+++ b/drivers/scsi/cxlflash/superpipe.c
@@ -1935,7 +1935,7 @@ static int cxlflash_disk_direct_open(struct scsi_device *sdev, void *arg)
  u64 lun_size = 0;
  u64 last_lba = 0;
  u64 rsrc_handle = -1;
- u32 port = CHAN2PORT(sdev->channel);
+ u32 port = CHAN2PORTMASK(sdev->channel);
 
  int rc = 0;
 
diff --git a/drivers/scsi/cxlflash/superpipe.h b/drivers/scsi/cxlflash/superpipe.h
index 690ce9c652b2..8269ff854bbe 100644
--- a/drivers/scsi/cxlflash/superpipe.h
+++ b/drivers/scsi/cxlflash/superpipe.h
@@ -33,9 +33,6 @@ extern struct cxlflash_global global;
 
 #define MAX_SECTOR_UNIT  512 /* max_sector is in 512 byte multiples */
 
-#define CHAN2PORT(_x) ((_x) + 1)
-#define PORT2CHAN(_x) ((_x) - 1)
-
 enum lun_mode {
  MODE_NONE = 0,
  MODE_VIRTUAL,
diff --git a/drivers/scsi/cxlflash/vlun.c b/drivers/scsi/cxlflash/vlun.c
index 8fcc804dbef9..547c8ffac205 100644
--- a/drivers/scsi/cxlflash/vlun.c
+++ b/drivers/scsi/cxlflash/vlun.c
@@ -819,8 +819,8 @@ int cxlflash_vlun_resize(struct scsi_device *sdev,
 void cxlflash_restore_luntable(struct cxlflash_cfg *cfg)
 {
  struct llun_info *lli, *temp;
- u32 chan;
  u32 lind;
+ int k;
  struct afu *afu = cfg->afu;
  struct device *dev = &cfg->dev->dev;
  struct sisl_global_map __iomem *agm = &afu->afu_map->global;
@@ -832,33 +832,41 @@ void cxlflash_restore_luntable(struct cxlflash_cfg *cfg)
  continue;
 
  lind = lli->lun_index;
+ dev_dbg(dev, "%s: Virtual LUNs on slot %d:\n", __func__, lind);
 
- if (lli->port_sel == BOTH_PORTS) {
- writeq_be(lli->lun_id[0], &agm->fc_port[0][lind]);
- writeq_be(lli->lun_id[1], &agm->fc_port[1][lind]);
- dev_dbg(dev, "%s: Virtual LUN on slot %d  id0=%llx "
- "id1=%llx\n", __func__, lind,
- lli->lun_id[0], lli->lun_id[1]);
- } else {
- chan = PORT2CHAN(lli->port_sel);
- writeq_be(lli->lun_id[chan], &agm->fc_port[chan][lind]);
- dev_dbg(dev, "%s: Virtual LUN on slot %d chan=%d "
- "id=%llx\n", __func__, lind, chan,
- lli->lun_id[chan]);
- }
+ for (k = 0; k < cfg->num_fc_ports; k++)
+ if (lli->port_sel & (1 << k)) {
+ writeq_be(lli->lun_id[k],
+  &agm->fc_port[k][lind]);
+ dev_dbg(dev, "\t%d=%llx\n", k, lli->lun_id[k]);
+ }
  }
 
  mutex_unlock(&global.mutex);
 }
 
 /**
+ * get_num_ports() - compute number of ports from port selection mask
+ * @psm: Port selection mask.
+ *
+ * Return: Population count of port selection mask
+ */
+static inline u8 get_num_ports(u32 psm)
+{
+ static const u8 bits[16] = { 0, 1, 1, 2, 1, 2, 2, 3,
+     1, 2, 2, 3, 2, 3, 3, 4 };
+
+ return bits[psm & 0xf];
+}
+
+/**
  * init_luntable() - write an entry in the LUN table
  * @cfg: Internal structure associated with the host.
  * @lli: Per adapter LUN information structure.
  *
- * On successful return, a LUN table entry is created.
- * At the top for LUNs visible on both ports.
- * At the bottom for LUNs visible only on one port.
+ * On successful return, a LUN table entry is created:
+ * - at the top for LUNs visible on multiple ports.
+ * - at the bottom for LUNs visible only on one port.
  *
  * Return: 0 on success, -errno on failure
  */
@@ -866,7 +874,9 @@ static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
 {
  u32 chan;
  u32 lind;
+ u32 nports;
  int rc = 0;
+ int k;
  struct afu *afu = cfg->afu;
  struct device *dev = &cfg->dev->dev;
  struct sisl_global_map __iomem *agm = &afu->afu_map->global;
@@ -876,29 +886,46 @@ static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
  if (lli->in_table)
  goto out;
 
- if (lli->port_sel == BOTH_PORTS) {
+ nports = get_num_ports(lli->port_sel);
+ if (nports == 0 || nports > cfg->num_fc_ports) {
+ WARN(1, "Unsupported port configuration nports=%u", nports);
+ rc = -EIO;
+ goto out;
+ }
+
+ if (nports > 1) {
  /*
- * If this LUN is visible from both ports, we will put
+ * When LUN is visible from multiple ports, we will put
  * it in the top half of the LUN table.
  */
- if ((cfg->promote_lun_index == cfg->last_lun_index[0]) ||
-    (cfg->promote_lun_index == cfg->last_lun_index[1])) {
- rc = -ENOSPC;
- goto out;
+ for (k = 0; k < cfg->num_fc_ports; k++) {
+ if (!(lli->port_sel & (1 << k)))
+ continue;
+
+ if (cfg->promote_lun_index == cfg->last_lun_index[k]) {
+ rc = -ENOSPC;
+ goto out;
+ }
  }
 
  lind = lli->lun_index = cfg->promote_lun_index;
- writeq_be(lli->lun_id[0], &agm->fc_port[0][lind]);
- writeq_be(lli->lun_id[1], &agm->fc_port[1][lind]);
+ dev_dbg(dev, "%s: Virtual LUNs on slot %d:\n", __func__, lind);
+
+ for (k = 0; k < cfg->num_fc_ports; k++) {
+ if (!(lli->port_sel & (1 << k)))
+ continue;
+
+ writeq_be(lli->lun_id[k], &agm->fc_port[k][lind]);
+ dev_dbg(dev, "\t%d=%llx\n", k, lli->lun_id[k]);
+ }
+
  cfg->promote_lun_index++;
- dev_dbg(dev, "%s: Virtual LUN on slot %d  id0=%llx id1=%llx\n",
- __func__, lind, lli->lun_id[0], lli->lun_id[1]);
  } else {
  /*
- * If this LUN is visible only from one port, we will put
+ * When LUN is visible only from one port, we will put
  * it in the bottom half of the LUN table.
  */
- chan = PORT2CHAN(lli->port_sel);
+ chan = PORTMASK2CHAN(lli->port_sel);
  if (cfg->promote_lun_index == cfg->last_lun_index[chan]) {
  rc = -ENOSPC;
  goto out;
@@ -907,7 +934,7 @@ static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
  lind = lli->lun_index = cfg->last_lun_index[chan];
  writeq_be(lli->lun_id[chan], &agm->fc_port[chan][lind]);
  cfg->last_lun_index[chan]--;
- dev_dbg(dev, "%s: Virtual LUN on slot %d  chan=%d id=%llx\n",
+ dev_dbg(dev, "%s: Virtual LUNs on slot %d:\n\t%d=%llx\n",
  __func__, lind, chan, lli->lun_id[chan]);
  }
 
@@ -1016,7 +1043,7 @@ int cxlflash_disk_virtual_open(struct scsi_device *sdev, void *arg)
  virt->last_lba = last_lba;
  virt->rsrc_handle = rsrc_handle;
 
- if (lli->port_sel == BOTH_PORTS)
+ if (get_num_ports(lli->port_sel) > 1)
  virt->hdr.return_flags |= DK_CXLFLASH_ALL_PORTS_ACTIVE;
 out:
  if (likely(ctxi))
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 12/44] scsi: cxlflash: Hide FC internals behind common access routine

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

As staging to support FC-related updates to the SISlite specification,
introduce helper routines to obtain references to FC resources that exist
within the global map. This will allow changes to the underlying global map
structure without impacting existing code paths.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 0aa14887c60c27e3385295ee85f5ac079ae2ffb5)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/common.h | 14 ++++++++
 drivers/scsi/cxlflash/main.c   | 72 +++++++++++++++++++++++-------------------
 drivers/scsi/cxlflash/vlun.c   | 16 +++++-----
 3 files changed, 61 insertions(+), 41 deletions(-)

diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h
index ee23e81994c4..e6a7c975c0dc 100644
--- a/drivers/scsi/cxlflash/common.h
+++ b/drivers/scsi/cxlflash/common.h
@@ -240,6 +240,20 @@ static inline u64 lun_to_lunid(u64 lun)
  return be64_to_cpu(lun_id);
 }
 
+static inline __be64 __iomem *get_fc_port_regs(struct cxlflash_cfg *cfg, int i)
+{
+ struct afu *afu = cfg->afu;
+
+ return &afu->afu_map->global.fc_regs[i][0];
+}
+
+static inline __be64 __iomem *get_fc_port_luns(struct cxlflash_cfg *cfg, int i)
+{
+ struct afu *afu = cfg->afu;
+
+ return &afu->afu_map->global.fc_port[i][0];
+}
+
 int cxlflash_afu_sync(struct afu *, ctx_hndl_t, res_hndl_t, u8);
 void cxlflash_list_init(void);
 void cxlflash_term_global_luns(void);
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 04e1a8effa76..e198605c3ded 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -670,8 +670,8 @@ static void notify_shutdown(struct cxlflash_cfg *cfg, bool wait)
 {
  struct afu *afu = cfg->afu;
  struct device *dev = &cfg->dev->dev;
- struct sisl_global_map __iomem *global;
  struct dev_dependent_vals *ddv;
+ __be64 __iomem *fc_port_regs;
  u64 reg, status;
  int i, retry_cnt = 0;
 
@@ -684,13 +684,13 @@ static void notify_shutdown(struct cxlflash_cfg *cfg, bool wait)
  return;
  }
 
- global = &afu->afu_map->global;
-
  /* Notify AFU */
  for (i = 0; i < cfg->num_fc_ports; i++) {
- reg = readq_be(&global->fc_regs[i][FC_CONFIG2 / 8]);
+ fc_port_regs = get_fc_port_regs(cfg, i);
+
+ reg = readq_be(&fc_port_regs[FC_CONFIG2 / 8]);
  reg |= SISL_FC_SHUTDOWN_NORMAL;
- writeq_be(reg, &global->fc_regs[i][FC_CONFIG2 / 8]);
+ writeq_be(reg, &fc_port_regs[FC_CONFIG2 / 8]);
  }
 
  if (!wait)
@@ -698,9 +698,11 @@ static void notify_shutdown(struct cxlflash_cfg *cfg, bool wait)
 
  /* Wait up to 1.5 seconds for shutdown processing to complete */
  for (i = 0; i < cfg->num_fc_ports; i++) {
+ fc_port_regs = get_fc_port_regs(cfg, i);
  retry_cnt = 0;
+
  while (true) {
- status = readq_be(&global->fc_regs[i][FC_STATUS / 8]);
+ status = readq_be(&fc_port_regs[FC_STATUS / 8]);
  if (status & SISL_STATUS_SHUTDOWN_COMPLETE)
  break;
  if (++retry_cnt >= MC_RETRY_CNT) {
@@ -1071,6 +1073,7 @@ static const struct asyc_intr_info *find_ainfo(u64 status)
 static void afu_err_intr_init(struct afu *afu)
 {
  struct cxlflash_cfg *cfg = afu->parent;
+ __be64 __iomem *fc_port_regs;
  int i;
  u64 reg;
 
@@ -1099,17 +1102,19 @@ static void afu_err_intr_init(struct afu *afu)
  writeq_be(-1ULL, &afu->afu_map->global.regs.aintr_clear);
 
  /* Clear/Set internal lun bits */
- reg = readq_be(&afu->afu_map->global.fc_regs[0][FC_CONFIG2 / 8]);
+ fc_port_regs = get_fc_port_regs(cfg, 0);
+ reg = readq_be(&fc_port_regs[FC_CONFIG2 / 8]);
  reg &= SISL_FC_INTERNAL_MASK;
  if (afu->internal_lun)
  reg |= ((u64)(afu->internal_lun - 1) << SISL_FC_INTERNAL_SHIFT);
- writeq_be(reg, &afu->afu_map->global.fc_regs[0][FC_CONFIG2 / 8]);
+ writeq_be(reg, &fc_port_regs[FC_CONFIG2 / 8]);
 
  /* now clear FC errors */
  for (i = 0; i < cfg->num_fc_ports; i++) {
- writeq_be(0xFFFFFFFFU,
-  &afu->afu_map->global.fc_regs[i][FC_ERROR / 8]);
- writeq_be(0, &afu->afu_map->global.fc_regs[i][FC_ERRCAP / 8]);
+ fc_port_regs = get_fc_port_regs(cfg, i);
+
+ writeq_be(0xFFFFFFFFU, &fc_port_regs[FC_ERROR / 8]);
+ writeq_be(0, &fc_port_regs[FC_ERRCAP / 8]);
  }
 
  /* sync interrupts for master's IOARRIN write */
@@ -1306,6 +1311,7 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
  u64 reg_unmasked;
  const struct asyc_intr_info *info;
  struct sisl_global_map __iomem *global = &afu->afu_map->global;
+ __be64 __iomem *fc_port_regs;
  u64 reg;
  u8 port;
  int i;
@@ -1329,10 +1335,11 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
  continue;
 
  port = info->port;
+ fc_port_regs = get_fc_port_regs(cfg, port);
 
  dev_err(dev, "%s: FC Port %d -> %s, fc_status=%016llx\n",
  __func__, port, info->desc,
-       readq_be(&global->fc_regs[port][FC_STATUS / 8]));
+       readq_be(&fc_port_regs[FC_STATUS / 8]));
 
  /*
  * Do link reset first, some OTHER errors will set FC_ERROR
@@ -1347,7 +1354,7 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
  }
 
  if (info->action & CLR_FC_ERROR) {
- reg = readq_be(&global->fc_regs[port][FC_ERROR / 8]);
+ reg = readq_be(&fc_port_regs[FC_ERROR / 8]);
 
  /*
  * Since all errors are unmasked, FC_ERROR and FC_ERRCAP
@@ -1357,8 +1364,8 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
  dev_err(dev, "%s: fc %d: clearing fc_error=%016llx\n",
  __func__, port, reg);
 
- writeq_be(reg, &global->fc_regs[port][FC_ERROR / 8]);
- writeq_be(0, &global->fc_regs[port][FC_ERRCAP / 8]);
+ writeq_be(reg, &fc_port_regs[FC_ERROR / 8]);
+ writeq_be(0, &fc_port_regs[FC_ERRCAP / 8]);
  }
 
  if (info->action & SCAN_HOST) {
@@ -1521,6 +1528,7 @@ static int init_global(struct cxlflash_cfg *cfg)
 {
  struct afu *afu = cfg->afu;
  struct device *dev = &cfg->dev->dev;
+ __be64 __iomem *fc_port_regs;
  u64 wwpn[MAX_FC_PORTS]; /* wwpn of AFU ports */
  int i = 0, num_ports = 0;
  int rc = 0;
@@ -1562,19 +1570,17 @@ static int init_global(struct cxlflash_cfg *cfg)
  }
 
  for (i = 0; i < num_ports; i++) {
+ fc_port_regs = get_fc_port_regs(cfg, i);
+
  /* Unmask all errors (but they are still masked at AFU) */
- writeq_be(0, &afu->afu_map->global.fc_regs[i][FC_ERRMSK / 8]);
+ writeq_be(0, &fc_port_regs[FC_ERRMSK / 8]);
  /* Clear CRC error cnt & set a threshold */
- (void)readq_be(&afu->afu_map->global.
-       fc_regs[i][FC_CNT_CRCERR / 8]);
- writeq_be(MC_CRC_THRESH, &afu->afu_map->global.fc_regs[i]
-  [FC_CRC_THRESH / 8]);
+ (void)readq_be(&fc_port_regs[FC_CNT_CRCERR / 8]);
+ writeq_be(MC_CRC_THRESH, &fc_port_regs[FC_CRC_THRESH / 8]);
 
  /* Set WWPNs. If already programmed, wwpn[i] is 0 */
  if (wwpn[i] != 0)
- afu_set_wwpn(afu, i,
-     &afu->afu_map->global.fc_regs[i][0],
-     wwpn[i]);
+ afu_set_wwpn(afu, i, &fc_port_regs[0], wwpn[i]);
  /* Programming WWPN back to back causes additional
  * offline/online transitions and a PLOGI
  */
@@ -2067,10 +2073,9 @@ static ssize_t cxlflash_show_port_status(u32 port,
  char *buf)
 {
  struct device *dev = &cfg->dev->dev;
- struct afu *afu = cfg->afu;
  char *disp_status;
  u64 status;
- __be64 __iomem *fc_regs;
+ __be64 __iomem *fc_port_regs;
 
  WARN_ON(port >= MAX_FC_PORTS);
 
@@ -2080,8 +2085,8 @@ static ssize_t cxlflash_show_port_status(u32 port,
  return -EINVAL;
  }
 
- fc_regs = &afu->afu_map->global.fc_regs[port][0];
- status = readq_be(&fc_regs[FC_MTIP_STATUS / 8]);
+ fc_port_regs = get_fc_port_regs(cfg, port);
+ status = readq_be(&fc_port_regs[FC_MTIP_STATUS / 8]);
  status &= FC_MTIP_STATUS_MASK;
 
  if (status == FC_MTIP_STATUS_ONLINE)
@@ -2225,10 +2230,9 @@ static ssize_t cxlflash_show_port_lun_table(u32 port,
     char *buf)
 {
  struct device *dev = &cfg->dev->dev;
- struct afu *afu = cfg->afu;
+ __be64 __iomem *fc_port_luns;
  int i;
  ssize_t bytes = 0;
- __be64 __iomem *fc_port;
 
  WARN_ON(port >= MAX_FC_PORTS);
 
@@ -2238,11 +2242,12 @@ static ssize_t cxlflash_show_port_lun_table(u32 port,
  return -EINVAL;
  }
 
- fc_port = &afu->afu_map->global.fc_port[port][0];
+ fc_port_luns = get_fc_port_luns(cfg, port);
 
  for (i = 0; i < CXLFLASH_NUM_VLUNS; i++)
  bytes += scnprintf(buf + bytes, PAGE_SIZE - bytes,
-   "%03d: %016llx\n", i, readq_be(&fc_port[i]));
+   "%03d: %016llx\n",
+   i, readq_be(&fc_port_luns[i]));
  return bytes;
 }
 
@@ -2462,6 +2467,7 @@ static void cxlflash_worker_thread(struct work_struct *work)
  work_q);
  struct afu *afu = cfg->afu;
  struct device *dev = &cfg->dev->dev;
+ __be64 __iomem *fc_port_regs;
  int port;
  ulong lock_flags;
 
@@ -2482,8 +2488,8 @@ static void cxlflash_worker_thread(struct work_struct *work)
        lock_flags);
 
  /* The reset can block... */
- afu_link_reset(afu, port,
-       &afu->afu_map->global.fc_regs[port][0]);
+ fc_port_regs = get_fc_port_regs(cfg, port);
+ afu_link_reset(afu, port, fc_port_regs);
  spin_lock_irqsave(cfg->host->host_lock, lock_flags);
  }
 
diff --git a/drivers/scsi/cxlflash/vlun.c b/drivers/scsi/cxlflash/vlun.c
index 547c8ffac205..9a6a9e9c7782 100644
--- a/drivers/scsi/cxlflash/vlun.c
+++ b/drivers/scsi/cxlflash/vlun.c
@@ -821,9 +821,8 @@ void cxlflash_restore_luntable(struct cxlflash_cfg *cfg)
  struct llun_info *lli, *temp;
  u32 lind;
  int k;
- struct afu *afu = cfg->afu;
  struct device *dev = &cfg->dev->dev;
- struct sisl_global_map __iomem *agm = &afu->afu_map->global;
+ __be64 __iomem *fc_port_luns;
 
  mutex_lock(&global.mutex);
 
@@ -836,8 +835,8 @@ void cxlflash_restore_luntable(struct cxlflash_cfg *cfg)
 
  for (k = 0; k < cfg->num_fc_ports; k++)
  if (lli->port_sel & (1 << k)) {
- writeq_be(lli->lun_id[k],
-  &agm->fc_port[k][lind]);
+ fc_port_luns = get_fc_port_luns(cfg, k);
+ writeq_be(lli->lun_id[k], &fc_port_luns[lind]);
  dev_dbg(dev, "\t%d=%llx\n", k, lli->lun_id[k]);
  }
  }
@@ -877,9 +876,8 @@ static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
  u32 nports;
  int rc = 0;
  int k;
- struct afu *afu = cfg->afu;
  struct device *dev = &cfg->dev->dev;
- struct sisl_global_map __iomem *agm = &afu->afu_map->global;
+ __be64 __iomem *fc_port_luns;
 
  mutex_lock(&global.mutex);
 
@@ -915,7 +913,8 @@ static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
  if (!(lli->port_sel & (1 << k)))
  continue;
 
- writeq_be(lli->lun_id[k], &agm->fc_port[k][lind]);
+ fc_port_luns = get_fc_port_luns(cfg, k);
+ writeq_be(lli->lun_id[k], &fc_port_luns[lind]);
  dev_dbg(dev, "\t%d=%llx\n", k, lli->lun_id[k]);
  }
 
@@ -932,7 +931,8 @@ static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
  }
 
  lind = lli->lun_index = cfg->last_lun_index[chan];
- writeq_be(lli->lun_id[chan], &agm->fc_port[chan][lind]);
+ fc_port_luns = get_fc_port_luns(cfg, chan);
+ writeq_be(lli->lun_id[chan], &fc_port_luns[lind]);
  cfg->last_lun_index[chan]--;
  dev_dbg(dev, "%s: Virtual LUNs on slot %d:\n\t%d=%llx\n",
  __func__, lind, chan, lli->lun_id[chan]);
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 13/44] scsi: cxlflash: SISlite updates to support 4 ports

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

Update the SISlite header to support 4 ports as outlined in the SISlite
specification. Address fallout from structure renames and refreshed
organization throughout the driver. Determine the number of ports supported by
a card from the global port selection mask register reset value.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 565180723294b06b3e60030033847277b9d6d4bb)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/common.h  | 25 ++++++++---
 drivers/scsi/cxlflash/main.c    | 77 +++++++++++++++++++++++++--------
 drivers/scsi/cxlflash/sislite.h | 96 ++++++++++++++++++++++++++++-------------
 3 files changed, 141 insertions(+), 57 deletions(-)

diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h
index e6a7c975c0dc..28bb716e78fe 100644
--- a/drivers/scsi/cxlflash/common.h
+++ b/drivers/scsi/cxlflash/common.h
@@ -26,8 +26,11 @@
 extern const struct file_operations cxlflash_cxl_fops;
 
 #define MAX_CONTEXT CXLFLASH_MAX_CONTEXT /* num contexts per afu */
-#define NUM_FC_PORTS CXLFLASH_NUM_FC_PORTS /* ports per AFU */
-#define MAX_FC_PORTS CXLFLASH_MAX_FC_PORTS /* ports per AFU */
+#define MAX_FC_PORTS CXLFLASH_MAX_FC_PORTS /* max ports per AFU */
+#define LEGACY_FC_PORTS 2 /* legacy ports per AFU */
+
+#define CHAN2PORTBANK(_x) ((_x) >> ilog2(CXLFLASH_NUM_FC_PORTS_PER_BANK))
+#define CHAN2BANKPORT(_x) ((_x) & (CXLFLASH_NUM_FC_PORTS_PER_BANK - 1))
 
 #define CHAN2PORTMASK(_x) (1 << (_x)) /* channel to port mask */
 #define PORTMASK2CHAN(_x) (ilog2((_x))) /* port mask to channel */
@@ -67,7 +70,7 @@ extern const struct file_operations cxlflash_cxl_fops;
 
 static inline void check_sizes(void)
 {
- BUILD_BUG_ON_NOT_POWER_OF_2(CXLFLASH_NUM_CMDS);
+ BUILD_BUG_ON_NOT_POWER_OF_2(CXLFLASH_NUM_FC_PORTS_PER_BANK);
 }
 
 /* AFU defines a fixed size of 4K for command buffers (borrow 4K page define) */
@@ -240,18 +243,26 @@ static inline u64 lun_to_lunid(u64 lun)
  return be64_to_cpu(lun_id);
 }
 
-static inline __be64 __iomem *get_fc_port_regs(struct cxlflash_cfg *cfg, int i)
+static inline struct fc_port_bank __iomem *get_fc_port_bank(
+    struct cxlflash_cfg *cfg, int i)
 {
  struct afu *afu = cfg->afu;
 
- return &afu->afu_map->global.fc_regs[i][0];
+ return &afu->afu_map->global.bank[CHAN2PORTBANK(i)];
+}
+
+static inline __be64 __iomem *get_fc_port_regs(struct cxlflash_cfg *cfg, int i)
+{
+ struct fc_port_bank __iomem *fcpb = get_fc_port_bank(cfg, i);
+
+ return &fcpb->fc_port_regs[CHAN2BANKPORT(i)][0];
 }
 
 static inline __be64 __iomem *get_fc_port_luns(struct cxlflash_cfg *cfg, int i)
 {
- struct afu *afu = cfg->afu;
+ struct fc_port_bank __iomem *fcpb = get_fc_port_bank(cfg, i);
 
- return &afu->afu_map->global.fc_port[i][0];
+ return &fcpb->fc_port_luns[CHAN2BANKPORT(i)][0];
 }
 
 int cxlflash_afu_sync(struct afu *, ctx_hndl_t, res_hndl_t, u8);
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index e198605c3ded..64ad76b6b672 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -1028,25 +1028,29 @@ static void afu_link_reset(struct afu *afu, int port, __be64 __iomem *fc_regs)
 
 /*
  * Asynchronous interrupt information table
+ *
+ * NOTE: The checkpatch script considers the BUILD_SISL_ASTATUS_FC_PORT macro
+ * as complex and complains because it is not wrapped with parentheses/braces.
  */
+#define ASTATUS_FC(_a, _b, _c, _d) \
+ { SISL_ASTATUS_FC##_a##_##_b, _c, _a, (_d) }
+
+#define BUILD_SISL_ASTATUS_FC_PORT(_a) \
+ ASTATUS_FC(_a, OTHER, "other error", CLR_FC_ERROR | LINK_RESET), \
+ ASTATUS_FC(_a, LOGO, "target initiated LOGO", 0), \
+ ASTATUS_FC(_a, CRC_T, "CRC threshold exceeded", LINK_RESET), \
+ ASTATUS_FC(_a, LOGI_R, "login timed out, retrying", LINK_RESET), \
+ ASTATUS_FC(_a, LOGI_F, "login failed", CLR_FC_ERROR), \
+ ASTATUS_FC(_a, LOGI_S, "login succeeded", SCAN_HOST), \
+ ASTATUS_FC(_a, LINK_DN, "link down", 0), \
+ ASTATUS_FC(_a, LINK_UP, "link up", 0)
+
 static const struct asyc_intr_info ainfo[] = {
- {SISL_ASTATUS_FC0_OTHER, "other error", 0, CLR_FC_ERROR | LINK_RESET},
- {SISL_ASTATUS_FC0_LOGO, "target initiated LOGO", 0, 0},
- {SISL_ASTATUS_FC0_CRC_T, "CRC threshold exceeded", 0, LINK_RESET},
- {SISL_ASTATUS_FC0_LOGI_R, "login timed out, retrying", 0, LINK_RESET},
- {SISL_ASTATUS_FC0_LOGI_F, "login failed", 0, CLR_FC_ERROR},
- {SISL_ASTATUS_FC0_LOGI_S, "login succeeded", 0, SCAN_HOST},
- {SISL_ASTATUS_FC0_LINK_DN, "link down", 0, 0},
- {SISL_ASTATUS_FC0_LINK_UP, "link up", 0, 0},
- {SISL_ASTATUS_FC1_OTHER, "other error", 1, CLR_FC_ERROR | LINK_RESET},
- {SISL_ASTATUS_FC1_LOGO, "target initiated LOGO", 1, 0},
- {SISL_ASTATUS_FC1_CRC_T, "CRC threshold exceeded", 1, LINK_RESET},
- {SISL_ASTATUS_FC1_LOGI_R, "login timed out, retrying", 1, LINK_RESET},
- {SISL_ASTATUS_FC1_LOGI_F, "login failed", 1, CLR_FC_ERROR},
- {SISL_ASTATUS_FC1_LOGI_S, "login succeeded", 1, SCAN_HOST},
- {SISL_ASTATUS_FC1_LINK_DN, "link down", 1, 0},
- {SISL_ASTATUS_FC1_LINK_UP, "link up", 1, 0},
- {0x0, "", 0, 0} /* terminator */
+ BUILD_SISL_ASTATUS_FC_PORT(2),
+ BUILD_SISL_ASTATUS_FC_PORT(3),
+ BUILD_SISL_ASTATUS_FC_PORT(0),
+ BUILD_SISL_ASTATUS_FC_PORT(1),
+ { 0x0, "", 0, 0 }
 };
 
 /**
@@ -1059,6 +1063,8 @@ static const struct asyc_intr_info *find_ainfo(u64 status)
 {
  const struct asyc_intr_info *info;
 
+ BUILD_BUG_ON(ainfo[ARRAY_SIZE(ainfo) - 1].status != 0);
+
  for (info = &ainfo[0]; info->status; info++)
  if (info->status == status)
  return info;
@@ -1747,6 +1753,39 @@ static int init_mc(struct cxlflash_cfg *cfg)
 }
 
 /**
+ * get_num_afu_ports() - determines and configures the number of AFU ports
+ * @cfg: Internal structure associated with the host.
+ *
+ * This routine determines the number of AFU ports by converting the global
+ * port selection mask. The converted value is only valid following an AFU
+ * reset (explicit or power-on). This routine must be invoked shortly after
+ * mapping as other routines are dependent on the number of ports during the
+ * initialization sequence.
+ *
+ * To support legacy AFUs that might not have reflected an initial global
+ * port mask (value read is 0), default to the number of ports originally
+ * supported by the cxlflash driver (2) before hardware with other port
+ * offerings was introduced.
+ */
+static void get_num_afu_ports(struct cxlflash_cfg *cfg)
+{
+ struct afu *afu = cfg->afu;
+ struct device *dev = &cfg->dev->dev;
+ u64 port_mask;
+ int num_fc_ports = LEGACY_FC_PORTS;
+
+ port_mask = readq_be(&afu->afu_map->global.regs.afu_port_sel);
+ if (port_mask != 0ULL)
+ num_fc_ports = min(ilog2(port_mask) + 1, MAX_FC_PORTS);
+
+ dev_dbg(dev, "%s: port_mask=%016llx num_fc_ports=%d\n",
+ __func__, port_mask, num_fc_ports);
+
+ cfg->num_fc_ports = num_fc_ports;
+ cfg->host->max_channel = PORTNUM2CHAN(num_fc_ports);
+}
+
+/**
  * init_afu() - setup as master context and start AFU
  * @cfg: Internal structure associated with the host.
  *
@@ -1803,6 +1842,8 @@ static int init_afu(struct cxlflash_cfg *cfg)
  dev_dbg(dev, "%s: afu_ver=%s interface_ver=%016llx\n", __func__,
  afu->version, afu->interface_version);
 
+ get_num_afu_ports(cfg);
+
  rc = start_afu(cfg);
  if (rc) {
  dev_err(dev, "%s: start_afu failed, rc=%d\n", __func__, rc);
@@ -2534,7 +2575,6 @@ static int cxlflash_probe(struct pci_dev *pdev,
 
  host->max_id = CXLFLASH_MAX_NUM_TARGETS_PER_BUS;
  host->max_lun = CXLFLASH_MAX_NUM_LUNS_PER_TARGET;
- host->max_channel = PORTNUM2CHAN(NUM_FC_PORTS);
  host->unique_id = host->host_no;
  host->max_cmd_len = CXLFLASH_MAX_CDB_LEN;
 
@@ -2550,7 +2590,6 @@ static int cxlflash_probe(struct pci_dev *pdev,
 
  cfg->init_state = INIT_STATE_NONE;
  cfg->dev = pdev;
- cfg->num_fc_ports = NUM_FC_PORTS;
  cfg->cxl_fops = cxlflash_cxl_fops;
 
  /*
diff --git a/drivers/scsi/cxlflash/sislite.h b/drivers/scsi/cxlflash/sislite.h
index f26f41be5efb..42d9c9ee3bce 100644
--- a/drivers/scsi/cxlflash/sislite.h
+++ b/drivers/scsi/cxlflash/sislite.h
@@ -292,28 +292,54 @@ struct sisl_ctrl_map {
 /* single copy global regs */
 struct sisl_global_regs {
  __be64 aintr_status;
- /* In cxlflash, each FC port/link gets a byte of status */
-#define SISL_ASTATUS_FC0_OTHER 0x8000ULL /* b48, other err,
-      FC_ERRCAP[31:20] */
-#define SISL_ASTATUS_FC0_LOGO    0x4000ULL /* b49, target sent FLOGI/PLOGI/LOGO
-   while logged in */
-#define SISL_ASTATUS_FC0_CRC_T   0x2000ULL /* b50, CRC threshold exceeded */
-#define SISL_ASTATUS_FC0_LOGI_R  0x1000ULL /* b51, login state machine timed out
-   and retrying */
-#define SISL_ASTATUS_FC0_LOGI_F  0x0800ULL /* b52, login failed,
-      FC_ERROR[19:0] */
-#define SISL_ASTATUS_FC0_LOGI_S  0x0400ULL /* b53, login succeeded */
-#define SISL_ASTATUS_FC0_LINK_DN 0x0200ULL /* b54, link online to offline */
-#define SISL_ASTATUS_FC0_LINK_UP 0x0100ULL /* b55, link offline to online */
-
-#define SISL_ASTATUS_FC1_OTHER   0x0080ULL /* b56 */
-#define SISL_ASTATUS_FC1_LOGO    0x0040ULL /* b57 */
-#define SISL_ASTATUS_FC1_CRC_T   0x0020ULL /* b58 */
-#define SISL_ASTATUS_FC1_LOGI_R  0x0010ULL /* b59 */
-#define SISL_ASTATUS_FC1_LOGI_F  0x0008ULL /* b60 */
-#define SISL_ASTATUS_FC1_LOGI_S  0x0004ULL /* b61 */
-#define SISL_ASTATUS_FC1_LINK_DN 0x0002ULL /* b62 */
-#define SISL_ASTATUS_FC1_LINK_UP 0x0001ULL /* b63 */
+ /*
+ * In cxlflash, FC port/link are arranged in port pairs, each
+ * gets a byte of status:
+ *
+ * *_OTHER: other err, FC_ERRCAP[31:20]
+ * *_LOGO: target sent FLOGI/PLOGI/LOGO while logged in
+ * *_CRC_T: CRC threshold exceeded
+ * *_LOGI_R: login state machine timed out and retrying
+ * *_LOGI_F: login failed, FC_ERROR[19:0]
+ * *_LOGI_S: login succeeded
+ * *_LINK_DN: link online to offline
+ * *_LINK_UP: link offline to online
+ */
+#define SISL_ASTATUS_FC2_OTHER 0x80000000ULL /* b32 */
+#define SISL_ASTATUS_FC2_LOGO    0x40000000ULL /* b33 */
+#define SISL_ASTATUS_FC2_CRC_T   0x20000000ULL /* b34 */
+#define SISL_ASTATUS_FC2_LOGI_R  0x10000000ULL /* b35 */
+#define SISL_ASTATUS_FC2_LOGI_F  0x08000000ULL /* b36 */
+#define SISL_ASTATUS_FC2_LOGI_S  0x04000000ULL /* b37 */
+#define SISL_ASTATUS_FC2_LINK_DN 0x02000000ULL /* b38 */
+#define SISL_ASTATUS_FC2_LINK_UP 0x01000000ULL /* b39 */
+
+#define SISL_ASTATUS_FC3_OTHER   0x00800000ULL /* b40 */
+#define SISL_ASTATUS_FC3_LOGO    0x00400000ULL /* b41 */
+#define SISL_ASTATUS_FC3_CRC_T   0x00200000ULL /* b42 */
+#define SISL_ASTATUS_FC3_LOGI_R  0x00100000ULL /* b43 */
+#define SISL_ASTATUS_FC3_LOGI_F  0x00080000ULL /* b44 */
+#define SISL_ASTATUS_FC3_LOGI_S  0x00040000ULL /* b45 */
+#define SISL_ASTATUS_FC3_LINK_DN 0x00020000ULL /* b46 */
+#define SISL_ASTATUS_FC3_LINK_UP 0x00010000ULL /* b47 */
+
+#define SISL_ASTATUS_FC0_OTHER 0x00008000ULL /* b48 */
+#define SISL_ASTATUS_FC0_LOGO    0x00004000ULL /* b49 */
+#define SISL_ASTATUS_FC0_CRC_T   0x00002000ULL /* b50 */
+#define SISL_ASTATUS_FC0_LOGI_R  0x00001000ULL /* b51 */
+#define SISL_ASTATUS_FC0_LOGI_F  0x00000800ULL /* b52 */
+#define SISL_ASTATUS_FC0_LOGI_S  0x00000400ULL /* b53 */
+#define SISL_ASTATUS_FC0_LINK_DN 0x00000200ULL /* b54 */
+#define SISL_ASTATUS_FC0_LINK_UP 0x00000100ULL /* b55 */
+
+#define SISL_ASTATUS_FC1_OTHER   0x00000080ULL /* b56 */
+#define SISL_ASTATUS_FC1_LOGO    0x00000040ULL /* b57 */
+#define SISL_ASTATUS_FC1_CRC_T   0x00000020ULL /* b58 */
+#define SISL_ASTATUS_FC1_LOGI_R  0x00000010ULL /* b59 */
+#define SISL_ASTATUS_FC1_LOGI_F  0x00000008ULL /* b60 */
+#define SISL_ASTATUS_FC1_LOGI_S  0x00000004ULL /* b61 */
+#define SISL_ASTATUS_FC1_LINK_DN 0x00000002ULL /* b62 */
+#define SISL_ASTATUS_FC1_LINK_UP 0x00000001ULL /* b63 */
 
 #define SISL_FC_INTERNAL_UNMASK 0x0000000300000000ULL /* 1 means unmasked */
 #define SISL_FC_INTERNAL_MASK ~(SISL_FC_INTERNAL_UNMASK)
@@ -325,7 +351,7 @@ struct sisl_global_regs {
 #define SISL_STATUS_SHUTDOWN_ACTIVE 0x0000000000000010ULL
 #define SISL_STATUS_SHUTDOWN_COMPLETE 0x0000000000000020ULL
 
-#define SISL_ASTATUS_UNMASK 0xFFFFULL /* 1 means unmasked */
+#define SISL_ASTATUS_UNMASK 0xFFFFFFFFULL /* 1 means unmasked */
 #define SISL_ASTATUS_MASK ~(SISL_ASTATUS_UNMASK) /* 1 means masked */
 
  __be64 aintr_clear;
@@ -367,10 +393,18 @@ struct sisl_global_regs {
 #define SISL_INTVER_CAP_RESERVED_CMD_MODE_B 0x100000000000ULL
 };
 
-#define CXLFLASH_MAX_FC_PORTS   2
-#define CXLFLASH_NUM_FC_PORTS   2
-#define CXLFLASH_MAX_CONTEXT  512 /* how many contexts per afu */
-#define CXLFLASH_NUM_VLUNS    512
+#define CXLFLASH_NUM_FC_PORTS_PER_BANK 2 /* fixed # of ports per bank */
+#define CXLFLASH_MAX_FC_BANKS 1 /* max # of banks supported */
+#define CXLFLASH_MAX_FC_PORTS (CXLFLASH_NUM_FC_PORTS_PER_BANK * \
+ CXLFLASH_MAX_FC_BANKS)
+#define CXLFLASH_MAX_CONTEXT 512 /* number of contexts per AFU */
+#define CXLFLASH_NUM_VLUNS 512 /* number of vluns per AFU/port */
+#define CXLFLASH_NUM_REGS 512 /* number of registers per port */
+
+struct fc_port_bank {
+ __be64 fc_port_regs[CXLFLASH_NUM_FC_PORTS_PER_BANK][CXLFLASH_NUM_REGS];
+ __be64 fc_port_luns[CXLFLASH_NUM_FC_PORTS_PER_BANK][CXLFLASH_NUM_VLUNS];
+};
 
 struct sisl_global_map {
  union {
@@ -380,11 +414,9 @@ struct sisl_global_map {
 
  char page1[SIZE_4K]; /* page 1 */
 
- /* pages 2 & 3 */
- __be64 fc_regs[CXLFLASH_NUM_FC_PORTS][CXLFLASH_NUM_VLUNS];
+ struct fc_port_bank bank[CXLFLASH_MAX_FC_BANKS]; /* pages 2 - 5 */
 
- /* pages 4 & 5 (lun tbl) */
- __be64 fc_port[CXLFLASH_NUM_FC_PORTS][CXLFLASH_NUM_VLUNS];
+ /* pages 6 - 15 are reserved */
 
 };
 
@@ -479,6 +511,8 @@ struct sisl_rht_entry_f1 {
 
 #define PORT0  0x01U
 #define PORT1  0x02U
+#define PORT2  0x04U
+#define PORT3  0x08U
 #define PORT_MASK(_n) ((1 << (_n)) - 1)
 
 /* AFU Sync Mode byte */
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 14/44] scsi: cxlflash: Support up to 4 ports

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

Update the driver to allow for future cards with 4 ports.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 1cd7fabc82eb06c834956113ff287f8848811fb8)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/main.c    | 78 ++++++++++++++++++++++++++++++++++++++++-
 drivers/scsi/cxlflash/sislite.h |  6 ++--
 2 files changed, 80 insertions(+), 4 deletions(-)

diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 64ad76b6b672..568cd636607a 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -1419,7 +1419,7 @@ static int read_vpd(struct cxlflash_cfg *cfg, u64 wwpn[])
  ssize_t vpd_size;
  char vpd_data[CXLFLASH_VPD_LEN];
  char tmp_buf[WWPN_BUF_LEN] = { 0 };
- char *wwpn_vpd_tags[MAX_FC_PORTS] = { "V5", "V6" };
+ char *wwpn_vpd_tags[MAX_FC_PORTS] = { "V5", "V6", "V7", "V8" };
 
  /* Get the VPD data from the device */
  vpd_size = cxl_read_adapter_vpd(pdev, vpd_data, sizeof(vpd_data));
@@ -2175,6 +2175,40 @@ static ssize_t port1_show(struct device *dev,
 }
 
 /**
+ * port2_show() - queries and presents the current status of port 2
+ * @dev: Generic device associated with the host owning the port.
+ * @attr: Device attribute representing the port.
+ * @buf: Buffer of length PAGE_SIZE to report back port status in ASCII.
+ *
+ * Return: The size of the ASCII string returned in @buf.
+ */
+static ssize_t port2_show(struct device *dev,
+  struct device_attribute *attr,
+  char *buf)
+{
+ struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
+
+ return cxlflash_show_port_status(2, cfg, buf);
+}
+
+/**
+ * port3_show() - queries and presents the current status of port 3
+ * @dev: Generic device associated with the host owning the port.
+ * @attr: Device attribute representing the port.
+ * @buf: Buffer of length PAGE_SIZE to report back port status in ASCII.
+ *
+ * Return: The size of the ASCII string returned in @buf.
+ */
+static ssize_t port3_show(struct device *dev,
+  struct device_attribute *attr,
+  char *buf)
+{
+ struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
+
+ return cxlflash_show_port_status(3, cfg, buf);
+}
+
+/**
  * lun_mode_show() - presents the current LUN mode of the host
  * @dev: Generic device associated with the host.
  * @attr: Device attribute representing the LUN mode.
@@ -2327,6 +2361,40 @@ static ssize_t port1_lun_table_show(struct device *dev,
 }
 
 /**
+ * port2_lun_table_show() - presents the current LUN table of port 2
+ * @dev: Generic device associated with the host owning the port.
+ * @attr: Device attribute representing the port.
+ * @buf: Buffer of length PAGE_SIZE to report back port status in ASCII.
+ *
+ * Return: The size of the ASCII string returned in @buf.
+ */
+static ssize_t port2_lun_table_show(struct device *dev,
+    struct device_attribute *attr,
+    char *buf)
+{
+ struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
+
+ return cxlflash_show_port_lun_table(2, cfg, buf);
+}
+
+/**
+ * port3_lun_table_show() - presents the current LUN table of port 3
+ * @dev: Generic device associated with the host owning the port.
+ * @attr: Device attribute representing the port.
+ * @buf: Buffer of length PAGE_SIZE to report back port status in ASCII.
+ *
+ * Return: The size of the ASCII string returned in @buf.
+ */
+static ssize_t port3_lun_table_show(struct device *dev,
+    struct device_attribute *attr,
+    char *buf)
+{
+ struct cxlflash_cfg *cfg = shost_priv(class_to_shost(dev));
+
+ return cxlflash_show_port_lun_table(3, cfg, buf);
+}
+
+/**
  * irqpoll_weight_show() - presents the current IRQ poll weight for the host
  * @dev: Generic device associated with the host.
  * @attr: Device attribute representing the IRQ poll weight.
@@ -2417,19 +2485,27 @@ static ssize_t mode_show(struct device *dev,
  */
 static DEVICE_ATTR_RO(port0);
 static DEVICE_ATTR_RO(port1);
+static DEVICE_ATTR_RO(port2);
+static DEVICE_ATTR_RO(port3);
 static DEVICE_ATTR_RW(lun_mode);
 static DEVICE_ATTR_RO(ioctl_version);
 static DEVICE_ATTR_RO(port0_lun_table);
 static DEVICE_ATTR_RO(port1_lun_table);
+static DEVICE_ATTR_RO(port2_lun_table);
+static DEVICE_ATTR_RO(port3_lun_table);
 static DEVICE_ATTR_RW(irqpoll_weight);
 
 static struct device_attribute *cxlflash_host_attrs[] = {
  &dev_attr_port0,
  &dev_attr_port1,
+ &dev_attr_port2,
+ &dev_attr_port3,
  &dev_attr_lun_mode,
  &dev_attr_ioctl_version,
  &dev_attr_port0_lun_table,
  &dev_attr_port1_lun_table,
+ &dev_attr_port2_lun_table,
+ &dev_attr_port3_lun_table,
  &dev_attr_irqpoll_weight,
  NULL
 };
diff --git a/drivers/scsi/cxlflash/sislite.h b/drivers/scsi/cxlflash/sislite.h
index 42d9c9ee3bce..0e52bbb6aeeb 100644
--- a/drivers/scsi/cxlflash/sislite.h
+++ b/drivers/scsi/cxlflash/sislite.h
@@ -394,7 +394,7 @@ struct sisl_global_regs {
 };
 
 #define CXLFLASH_NUM_FC_PORTS_PER_BANK 2 /* fixed # of ports per bank */
-#define CXLFLASH_MAX_FC_BANKS 1 /* max # of banks supported */
+#define CXLFLASH_MAX_FC_BANKS 2 /* max # of banks supported */
 #define CXLFLASH_MAX_FC_PORTS (CXLFLASH_NUM_FC_PORTS_PER_BANK * \
  CXLFLASH_MAX_FC_BANKS)
 #define CXLFLASH_MAX_CONTEXT 512 /* number of contexts per AFU */
@@ -414,9 +414,9 @@ struct sisl_global_map {
 
  char page1[SIZE_4K]; /* page 1 */
 
- struct fc_port_bank bank[CXLFLASH_MAX_FC_BANKS]; /* pages 2 - 5 */
+ struct fc_port_bank bank[CXLFLASH_MAX_FC_BANKS]; /* pages 2 - 9 */
 
- /* pages 6 - 15 are reserved */
+ /* pages 10 - 15 are reserved */
 
 };
 
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 15/44] scsi: cxlflash: Fence EEH during probe

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

An EEH during probe can lead to a crash as the recovery thread races with the
probe thread. To avoid this issue, introduce new states to fence out EEH
recovery until probe has completed. Also ensure the reset wait queue is
flushed during device removal to avoid orphaned threads.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 323e33428ea23bfb1ae5010b18b4540048b2ad51)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/common.h    |  2 ++
 drivers/scsi/cxlflash/main.c      | 25 +++++++++++++++++++++----
 drivers/scsi/cxlflash/superpipe.c |  8 +++++---
 3 files changed, 28 insertions(+), 7 deletions(-)

diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h
index 28bb716e78fe..17aa74a83d39 100644
--- a/drivers/scsi/cxlflash/common.h
+++ b/drivers/scsi/cxlflash/common.h
@@ -90,6 +90,8 @@ enum cxlflash_init_state {
 };
 
 enum cxlflash_state {
+ STATE_PROBING, /* Initial state during probe */
+ STATE_PROBED, /* Temporary state, probe completed but EEH occurred */
  STATE_NORMAL, /* Normal running state, everything good */
  STATE_RESET, /* Reset state, trying to reset/recover */
  STATE_FAILTERM /* Failed/terminating state, error out users/threads */
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 568cd636607a..ebba3c90a242 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -470,6 +470,8 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
  spin_unlock_irqrestore(&cfg->tmf_slock, lock_flags);
 
  switch (cfg->state) {
+ case STATE_PROBING:
+ case STATE_PROBED:
  case STATE_RESET:
  dev_dbg_ratelimited(dev, "%s: device is in reset\n", __func__);
  rc = SCSI_MLQUEUE_HOST_BUSY;
@@ -719,7 +721,8 @@ static void notify_shutdown(struct cxlflash_cfg *cfg, bool wait)
  * cxlflash_remove() - PCI entry point to tear down host
  * @pdev: PCI device associated with the host.
  *
- * Safe to use as a cleanup in partially allocated/initialized state.
+ * Safe to use as a cleanup in partially allocated/initialized state. Note that
+ * the reset_waitq is flushed as part of the stop/termination of user contexts.
  */
 static void cxlflash_remove(struct pci_dev *pdev)
 {
@@ -752,7 +755,6 @@ static void cxlflash_remove(struct pci_dev *pdev)
  case INIT_STATE_SCSI:
  cxlflash_term_local_luns(cfg);
  scsi_remove_host(cfg->host);
- /* fall through */
  case INIT_STATE_AFU:
  term_afu(cfg);
  case INIT_STATE_PCI:
@@ -2624,6 +2626,15 @@ static void cxlflash_worker_thread(struct work_struct *work)
  * @pdev: PCI device associated with the host.
  * @dev_id: PCI device id associated with device.
  *
+ * The device will initially start out in a 'probing' state and
+ * transition to the 'normal' state at the end of a successful
+ * probe. Should an EEH event occur during probe, the notification
+ * thread (error_detected()) will wait until the probe handler
+ * is nearly complete. At that time, the device will be moved to
+ * a 'probed' state and the EEH thread woken up to drive the slot
+ * reset and recovery (device moves to 'normal' state). Meanwhile,
+ * the probe will be allowed to exit successfully.
+ *
  * Return: 0 on success, -errno on failure
  */
 static int cxlflash_probe(struct pci_dev *pdev,
@@ -2707,7 +2718,7 @@ static int cxlflash_probe(struct pci_dev *pdev,
  cfg->init_state = INIT_STATE_PCI;
 
  rc = init_afu(cfg);
- if (rc) {
+ if (rc && !wq_has_sleeper(&cfg->reset_waitq)) {
  dev_err(dev, "%s: init_afu failed rc=%d\n", __func__, rc);
  goto out_remove;
  }
@@ -2720,6 +2731,11 @@ static int cxlflash_probe(struct pci_dev *pdev,
  }
  cfg->init_state = INIT_STATE_SCSI;
 
+ if (wq_has_sleeper(&cfg->reset_waitq)) {
+ cfg->state = STATE_PROBED;
+ wake_up_all(&cfg->reset_waitq);
+ } else
+ cfg->state = STATE_NORMAL;
 out:
  dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
  return rc;
@@ -2750,7 +2766,8 @@ static pci_ers_result_t cxlflash_pci_error_detected(struct pci_dev *pdev,
 
  switch (state) {
  case pci_channel_io_frozen:
- wait_event(cfg->reset_waitq, cfg->state != STATE_RESET);
+ wait_event(cfg->reset_waitq, cfg->state != STATE_RESET &&
+     cfg->state != STATE_PROBING);
  if (cfg->state == STATE_FAILTERM)
  return PCI_ERS_RESULT_DISCONNECT;
 
diff --git a/drivers/scsi/cxlflash/superpipe.c b/drivers/scsi/cxlflash/superpipe.c
index 488330ffdf02..158fa0099c37 100644
--- a/drivers/scsi/cxlflash/superpipe.c
+++ b/drivers/scsi/cxlflash/superpipe.c
@@ -78,17 +78,18 @@ void cxlflash_free_errpage(void)
  * memory freed. This is accomplished by putting the contexts in error
  * state which will notify the user and let them 'drive' the tear down.
  * Meanwhile, this routine camps until all user contexts have been removed.
+ *
+ * Note that the main loop in this routine will always execute at least once
+ * to flush the reset_waitq.
  */
 void cxlflash_stop_term_user_contexts(struct cxlflash_cfg *cfg)
 {
  struct device *dev = &cfg->dev->dev;
- int i, found;
+ int i, found = true;
 
  cxlflash_mark_contexts_error(cfg);
 
  while (true) {
- found = false;
-
  for (i = 0; i < MAX_CONTEXT; i++)
  if (cfg->ctx_tbl[i]) {
  found = true;
@@ -102,6 +103,7 @@ void cxlflash_stop_term_user_contexts(struct cxlflash_cfg *cfg)
  __func__);
  wake_up_all(&cfg->reset_waitq);
  ssleep(1);
+ found = false;
  }
 }
 
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 16/44] scsi: cxlflash: Remove unnecessary DMA mapping

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

Devices supported by the cxlflash driver are fully coherent and do not require
a bus address mapping. Avoid unnecessary path length by using the virtual
address and length already present in the scatter-gather entry.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit 50b787f7235efbd074bbdf4315e0cc261d85b4d7)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/main.c | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index ebba3c90a242..3c4a83307e6e 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -176,7 +176,6 @@ static void cmd_complete(struct afu_cmd *cmd)
  dev_dbg_ratelimited(dev, "%s:scp=%p result=%08x ioasc=%08x\n",
     __func__, scp, scp->result, cmd->sa.ioasc);
 
- scsi_dma_unmap(scp);
  scp->scsi_done(scp);
 
  if (cmd_is_tmf) {
@@ -445,7 +444,6 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
  struct scatterlist *sg = scsi_sglist(scp);
  u16 req_flags = SISL_REQ_FLAGS_SUP_UNDERRUN;
  ulong lock_flags;
- int nseg = 0;
  int rc = 0;
 
  dev_dbg_ratelimited(dev, "%s: (scp=%p) %d/%d/%d/%llu "
@@ -487,15 +485,8 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
  }
 
  if (likely(sg)) {
- nseg = scsi_dma_map(scp);
- if (unlikely(nseg < 0)) {
- dev_err(dev, "%s: Fail DMA map\n", __func__);
- rc = SCSI_MLQUEUE_HOST_BUSY;
- goto out;
- }
-
- cmd->rcb.data_len = sg_dma_len(sg);
- cmd->rcb.data_ea = sg_dma_address(sg);
+ cmd->rcb.data_len = sg->length;
+ cmd->rcb.data_ea = (uintptr_t)sg_virt(sg);
  }
 
  cmd->scp = scp;
@@ -513,8 +504,6 @@ static int cxlflash_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scp)
  memcpy(cmd->rcb.cdb, scp->cmnd, sizeof(cmd->rcb.cdb));
 
  rc = afu->send_cmd(afu, cmd);
- if (unlikely(rc))
- scsi_dma_unmap(scp);
 out:
  return rc;
 }
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 17/44] scsi: cxlflash: Fix power-of-two validations

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

Validation statements to enforce assumptions about specific defines are not
being evaluated by the compiler due to the fact that they reside in a routine
that is not used. To activate them, call the routine as part of module
initialization. As an additional, related cleanup, remove the now-defunct
CXLFLASH_NUM_CMDS.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit cd41e18daf1a21fea5a195a5a74c97c6b183c15a)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/common.h | 7 +------
 drivers/scsi/cxlflash/main.c   | 1 +
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h
index 17aa74a83d39..455fd4dffac8 100644
--- a/drivers/scsi/cxlflash/common.h
+++ b/drivers/scsi/cxlflash/common.h
@@ -52,12 +52,6 @@ extern const struct file_operations cxlflash_cxl_fops;
    certain AFU errors */
 
 /* Command management definitions */
-#define CXLFLASH_NUM_CMDS (2 * CXLFLASH_MAX_CMDS) /* Must be a pow2 for
-   alignment and more
-   efficient array
-   index derivation
- */
-
 #define CXLFLASH_MAX_CMDS               256
 #define CXLFLASH_MAX_CMDS_PER_LUN       CXLFLASH_MAX_CMDS
 
@@ -71,6 +65,7 @@ extern const struct file_operations cxlflash_cxl_fops;
 static inline void check_sizes(void)
 {
  BUILD_BUG_ON_NOT_POWER_OF_2(CXLFLASH_NUM_FC_PORTS_PER_BANK);
+ BUILD_BUG_ON_NOT_POWER_OF_2(CXLFLASH_MAX_CMDS);
 }
 
 /* AFU defines a fixed size of 4K for command buffers (borrow 4K page define) */
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 3c4a83307e6e..f5c952c953f7 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -2847,6 +2847,7 @@ static struct pci_driver cxlflash_driver = {
  */
 static int __init init_cxlflash(void)
 {
+ check_sizes();
  cxlflash_list_init();
 
  return pci_register_driver(&cxlflash_driver);
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 18/44] scsi: cxlflash: Fix warnings/errors

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

As a general cleanup, address all reasonable checkpatch warnings and
errors. These include enforcement of comment styles and including named
identifiers in function prototypes.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit fcc87e74a987dc9c0c85f53546df944ede76486a)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/common.h    | 27 ++++++++++-----------
 drivers/scsi/cxlflash/sislite.h   | 27 +++++++++++----------
 drivers/scsi/cxlflash/superpipe.h | 51 ++++++++++++++++++++++-----------------
 drivers/scsi/cxlflash/vlun.h      |  2 +-
 4 files changed, 57 insertions(+), 50 deletions(-)

diff --git a/drivers/scsi/cxlflash/common.h b/drivers/scsi/cxlflash/common.h
index 455fd4dffac8..c69cdcf8664d 100644
--- a/drivers/scsi/cxlflash/common.h
+++ b/drivers/scsi/cxlflash/common.h
@@ -36,20 +36,19 @@ extern const struct file_operations cxlflash_cxl_fops;
 #define PORTMASK2CHAN(_x) (ilog2((_x))) /* port mask to channel */
 #define PORTNUM2CHAN(_x) ((_x) - 1) /* port number to channel */
 
-#define CXLFLASH_BLOCK_SIZE 4096 /* 4K blocks */
+#define CXLFLASH_BLOCK_SIZE 4096 /* 4K blocks */
 #define CXLFLASH_MAX_XFER_SIZE 16777216 /* 16MB transfer */
 #define CXLFLASH_MAX_SECTORS (CXLFLASH_MAX_XFER_SIZE/512) /* SCSI wants
-   max_sectors
-   in units of
-   512 byte
-   sectors
- */
+ * max_sectors
+ * in units of
+ * 512 byte
+ * sectors
+ */
 
 #define MAX_RHT_PER_CONTEXT (PAGE_SIZE / sizeof(struct sisl_rht_entry))
 
 /* AFU command retry limit */
-#define MC_RETRY_CNT         5 /* sufficient for SCSI check and
-   certain AFU errors */
+#define MC_RETRY_CNT 5 /* Sufficient for SCSI and certain AFU errors */
 
 /* Command management definitions */
 #define CXLFLASH_MAX_CMDS               256
@@ -262,14 +261,14 @@ static inline __be64 __iomem *get_fc_port_luns(struct cxlflash_cfg *cfg, int i)
  return &fcpb->fc_port_luns[CHAN2BANKPORT(i)][0];
 }
 
-int cxlflash_afu_sync(struct afu *, ctx_hndl_t, res_hndl_t, u8);
+int cxlflash_afu_sync(struct afu *afu, ctx_hndl_t c, res_hndl_t r, u8 mode);
 void cxlflash_list_init(void);
 void cxlflash_term_global_luns(void);
 void cxlflash_free_errpage(void);
-int cxlflash_ioctl(struct scsi_device *, int, void __user *);
-void cxlflash_stop_term_user_contexts(struct cxlflash_cfg *);
-int cxlflash_mark_contexts_error(struct cxlflash_cfg *);
-void cxlflash_term_local_luns(struct cxlflash_cfg *);
-void cxlflash_restore_luntable(struct cxlflash_cfg *);
+int cxlflash_ioctl(struct scsi_device *sdev, int cmd, void __user *arg);
+void cxlflash_stop_term_user_contexts(struct cxlflash_cfg *cfg);
+int cxlflash_mark_contexts_error(struct cxlflash_cfg *cfg);
+void cxlflash_term_local_luns(struct cxlflash_cfg *cfg);
+void cxlflash_restore_luntable(struct cxlflash_cfg *cfg);
 
 #endif /* ifndef _CXLFLASH_COMMON_H */
diff --git a/drivers/scsi/cxlflash/sislite.h b/drivers/scsi/cxlflash/sislite.h
index 0e52bbb6aeeb..a768360d2fa6 100644
--- a/drivers/scsi/cxlflash/sislite.h
+++ b/drivers/scsi/cxlflash/sislite.h
@@ -90,15 +90,15 @@ struct sisl_rc {
 #define SISL_AFU_RC_RHT_UNALIGNED         0x02U /* should never happen */
 #define SISL_AFU_RC_RHT_OUT_OF_BOUNDS     0x03u /* user error */
 #define SISL_AFU_RC_RHT_DMA_ERR           0x04u /* see afu_extra
-   may retry if afu_retry is off
-   possible on master exit
+ * may retry if afu_retry is off
+ * possible on master exit
  */
 #define SISL_AFU_RC_RHT_RW_PERM           0x05u /* no RW perms, user error */
 #define SISL_AFU_RC_LXT_UNALIGNED         0x12U /* should never happen */
 #define SISL_AFU_RC_LXT_OUT_OF_BOUNDS     0x13u /* user error */
 #define SISL_AFU_RC_LXT_DMA_ERR           0x14u /* see afu_extra
-   may retry if afu_retry is off
-   possible on master exit
+ * may retry if afu_retry is off
+ * possible on master exit
  */
 #define SISL_AFU_RC_LXT_RW_PERM           0x15u /* no RW perms, user error */
 
@@ -111,11 +111,11 @@ struct sisl_rc {
  */
 #define SISL_AFU_RC_NO_CHANNELS           0x20U /* see afu_extra, may retry */
 #define SISL_AFU_RC_CAP_VIOLATION         0x21U /* either user error or
-   afu reset/master restart
+ * afu reset/master restart
  */
 #define SISL_AFU_RC_OUT_OF_DATA_BUFS      0x30U /* always retry */
 #define SISL_AFU_RC_DATA_DMA_ERR          0x31U /* see afu_extra
-   may retry if afu_retry is off
+ * may retry if afu_retry is off
  */
 
  u8 scsi_rc; /* SCSI status byte, retry as appropriate */
@@ -149,8 +149,9 @@ struct sisl_rc {
 #define SISL_FC_RC_ABORTFAIL 0x59 /* pending abort completed w/fail */
 #define SISL_FC_RC_RESID 0x5A /* ioasa underrun/overrun flags set */
 #define SISL_FC_RC_RESIDERR 0x5B /* actual data len does not match SCSI
-   reported len, possibly due to dropped
-   frames */
+ * reported len, possibly due to dropped
+ * frames
+ */
 #define SISL_FC_RC_TGTABORT 0x5C /* command aborted by target */
 };
 
@@ -227,10 +228,10 @@ struct sisl_ioasa {
 
 /* per context host transport MMIO  */
 struct sisl_host_map {
- __be64 endian_ctrl;     /* Per context Endian Control. The AFU will
-      * operate on whatever the context is of the
-      * host application.
-      */
+ __be64 endian_ctrl; /* Per context Endian Control. The AFU will
+ * operate on whatever the context is of the
+ * host application.
+ */
 
  __be64 intr_status; /* this sends LISN# programmed in ctx_ctrl.
  * Only recovery in a PERM_ERR is a context
@@ -435,7 +436,7 @@ struct sisl_global_map {
  * |         64 KB Global          |
  * |   Trusted Process accessible  |
  * +-------------------------------+
-*/
+ */
 struct cxlflash_afu_map {
  union {
  struct sisl_host_map host;
diff --git a/drivers/scsi/cxlflash/superpipe.h b/drivers/scsi/cxlflash/superpipe.h
index 8269ff854bbe..0b5976829913 100644
--- a/drivers/scsi/cxlflash/superpipe.h
+++ b/drivers/scsi/cxlflash/superpipe.h
@@ -24,8 +24,8 @@ extern struct cxlflash_global global;
  */
 
 /* Chunk size parms: note sislite minimum chunk size is
-   0x10000 LBAs corresponding to a NMASK or 16.
-*/
+ * 0x10000 LBAs corresponding to a NMASK or 16.
+ */
 #define MC_CHUNK_SIZE     (1 << MC_RHT_NMASK) /* in LBAs */
 
 #define CMD_TIMEOUT 30  /* 30 secs */
@@ -89,7 +89,8 @@ enum ctx_ctrl {
 struct ctx_info {
  struct sisl_ctrl_map __iomem *ctrl_map; /* initialized at startup */
  struct sisl_rht_entry *rht_start; /* 1 page (req'd for alignment),
-     alloc/free on attach/detach */
+   * alloc/free on attach/detach
+   */
  u32 rht_out; /* Number of checked out RHT entries */
  u32 rht_perms; /* User-defined permissions for RHT entries */
  struct llun_info **rht_lun;       /* Mapping of RHT entries to LUNs */
@@ -117,34 +118,40 @@ struct cxlflash_global {
  struct page *err_page; /* One page of all 0xF for error notification */
 };
 
-int cxlflash_vlun_resize(struct scsi_device *, struct dk_cxlflash_resize *);
-int _cxlflash_vlun_resize(struct scsi_device *, struct ctx_info *,
-  struct dk_cxlflash_resize *);
+int cxlflash_vlun_resize(struct scsi_device *sdev,
+ struct dk_cxlflash_resize *resize);
+int _cxlflash_vlun_resize(struct scsi_device *sdev, struct ctx_info *ctxi,
+  struct dk_cxlflash_resize *resize);
 
-int cxlflash_disk_release(struct scsi_device *, struct dk_cxlflash_release *);
-int _cxlflash_disk_release(struct scsi_device *, struct ctx_info *,
-   struct dk_cxlflash_release *);
+int cxlflash_disk_release(struct scsi_device *sdev,
+  struct dk_cxlflash_release *release);
+int _cxlflash_disk_release(struct scsi_device *sdev, struct ctx_info *ctxi,
+   struct dk_cxlflash_release *release);
 
-int cxlflash_disk_clone(struct scsi_device *, struct dk_cxlflash_clone *);
+int cxlflash_disk_clone(struct scsi_device *sdev,
+ struct dk_cxlflash_clone *clone);
 
-int cxlflash_disk_virtual_open(struct scsi_device *, void *);
+int cxlflash_disk_virtual_open(struct scsi_device *sdev, void *arg);
 
-int cxlflash_lun_attach(struct glun_info *, enum lun_mode, bool);
-void cxlflash_lun_detach(struct glun_info *);
+int cxlflash_lun_attach(struct glun_info *gli, enum lun_mode mode, bool locked);
+void cxlflash_lun_detach(struct glun_info *gli);
 
-struct ctx_info *get_context(struct cxlflash_cfg *, u64, void *, enum ctx_ctrl);
-void put_context(struct ctx_info *);
+struct ctx_info *get_context(struct cxlflash_cfg *cfg, u64 rctxit, void *arg,
+     enum ctx_ctrl ctrl);
+void put_context(struct ctx_info *ctxi);
 
-struct sisl_rht_entry *get_rhte(struct ctx_info *, res_hndl_t,
- struct llun_info *);
+struct sisl_rht_entry *get_rhte(struct ctx_info *ctxi, res_hndl_t rhndl,
+ struct llun_info *lli);
 
-struct sisl_rht_entry *rhte_checkout(struct ctx_info *, struct llun_info *);
-void rhte_checkin(struct ctx_info *, struct sisl_rht_entry *);
+struct sisl_rht_entry *rhte_checkout(struct ctx_info *ctxi,
+     struct llun_info *lli);
+void rhte_checkin(struct ctx_info *ctxi, struct sisl_rht_entry *rhte);
 
-void cxlflash_ba_terminate(struct ba_lun *);
+void cxlflash_ba_terminate(struct ba_lun *ba_lun);
 
-int cxlflash_manage_lun(struct scsi_device *, struct dk_cxlflash_manage_lun *);
+int cxlflash_manage_lun(struct scsi_device *sdev,
+ struct dk_cxlflash_manage_lun *manage);
 
-int check_state(struct cxlflash_cfg *);
+int check_state(struct cxlflash_cfg *cfg);
 
 #endif /* ifndef _CXLFLASH_SUPERPIPE_H */
diff --git a/drivers/scsi/cxlflash/vlun.h b/drivers/scsi/cxlflash/vlun.h
index 8b29a74946e4..27a63a0155ce 100644
--- a/drivers/scsi/cxlflash/vlun.h
+++ b/drivers/scsi/cxlflash/vlun.h
@@ -47,7 +47,7 @@
  * not stored anywhere.
  *
  * The LXT table is re-allocated whenever it needs to cross into another group.
-*/
+ */
 #define LXT_GROUP_SIZE          8
 #define LXT_NUM_GROUPS(lxt_cnt) (((lxt_cnt) + 7)/8) /* alloc'ed groups */
 #define LXT_LUNIDX_SHIFT  8 /* LXT entry, shift for LUN index */
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[Zesty][PATCH 19/44] scsi: cxlflash: Improve asynchronous interrupt processing

Victor Aoqui
In reply to this post by Victor Aoqui
From: "Matthew R. Ochs" <[hidden email]>

BugLink: http://bugs.launchpad.net/bugs/1702521

The method used to decode asynchronous interrupts involves unnecessary loops
to match up bits that are set with corresponding entries in the asynchronous
interrupt information table. This algorithm is wasteful and does not scale
well as new status bits are supported.

As an improvement, use the for_each_set_bit() service to iterate over the
asynchronous status bits and refactor the information table such that it can
be indexed by bit position.

Signed-off-by: Matthew R. Ochs <[hidden email]>
Signed-off-by: Uma Krishnan <[hidden email]>
Signed-off-by: Martin K. Petersen <[hidden email]>
(cherry picked from commit e2ef33fa5958c51ebf0c6f18db19fe927e2185fa)
Signed-off-by: Victor Aoqui <[hidden email]>
---
 drivers/scsi/cxlflash/main.c | 94 ++++++++++++++++++++------------------------
 1 file changed, 42 insertions(+), 52 deletions(-)

diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index f5c952c953f7..c60936fb70bb 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -1017,52 +1017,6 @@ static void afu_link_reset(struct afu *afu, int port, __be64 __iomem *fc_regs)
  dev_dbg(dev, "%s: returning port_sel=%016llx\n", __func__, port_sel);
 }
 
-/*
- * Asynchronous interrupt information table
- *
- * NOTE: The checkpatch script considers the BUILD_SISL_ASTATUS_FC_PORT macro
- * as complex and complains because it is not wrapped with parentheses/braces.
- */
-#define ASTATUS_FC(_a, _b, _c, _d) \
- { SISL_ASTATUS_FC##_a##_##_b, _c, _a, (_d) }
-
-#define BUILD_SISL_ASTATUS_FC_PORT(_a) \
- ASTATUS_FC(_a, OTHER, "other error", CLR_FC_ERROR | LINK_RESET), \
- ASTATUS_FC(_a, LOGO, "target initiated LOGO", 0), \
- ASTATUS_FC(_a, CRC_T, "CRC threshold exceeded", LINK_RESET), \
- ASTATUS_FC(_a, LOGI_R, "login timed out, retrying", LINK_RESET), \
- ASTATUS_FC(_a, LOGI_F, "login failed", CLR_FC_ERROR), \
- ASTATUS_FC(_a, LOGI_S, "login succeeded", SCAN_HOST), \
- ASTATUS_FC(_a, LINK_DN, "link down", 0), \
- ASTATUS_FC(_a, LINK_UP, "link up", 0)
-
-static const struct asyc_intr_info ainfo[] = {
- BUILD_SISL_ASTATUS_FC_PORT(2),
- BUILD_SISL_ASTATUS_FC_PORT(3),
- BUILD_SISL_ASTATUS_FC_PORT(0),
- BUILD_SISL_ASTATUS_FC_PORT(1),
- { 0x0, "", 0, 0 }
-};
-
-/**
- * find_ainfo() - locates and returns asynchronous interrupt information
- * @status: Status code set by AFU on error.
- *
- * Return: The located information or NULL when the status code is invalid.
- */
-static const struct asyc_intr_info *find_ainfo(u64 status)
-{
- const struct asyc_intr_info *info;
-
- BUILD_BUG_ON(ainfo[ARRAY_SIZE(ainfo) - 1].status != 0);
-
- for (info = &ainfo[0]; info->status; info++)
- if (info->status == status)
- return info;
-
- return NULL;
-}
-
 /**
  * afu_err_intr_init() - clears and initializes the AFU for error interrupts
  * @afu: AFU associated with the host.
@@ -1293,6 +1247,35 @@ static irqreturn_t cxlflash_rrq_irq(int irq, void *data)
  return IRQ_HANDLED;
 }
 
+/*
+ * Asynchronous interrupt information table
+ *
+ * NOTE:
+ * - Order matters here as this array is indexed by bit position.
+ *
+ * - The checkpatch script considers the BUILD_SISL_ASTATUS_FC_PORT macro
+ *  as complex and complains due to a lack of parentheses/braces.
+ */
+#define ASTATUS_FC(_a, _b, _c, _d) \
+ { SISL_ASTATUS_FC##_a##_##_b, _c, _a, (_d) }
+
+#define BUILD_SISL_ASTATUS_FC_PORT(_a) \
+ ASTATUS_FC(_a, LINK_UP, "link up", 0), \
+ ASTATUS_FC(_a, LINK_DN, "link down", 0), \
+ ASTATUS_FC(_a, LOGI_S, "login succeeded", SCAN_HOST), \
+ ASTATUS_FC(_a, LOGI_F, "login failed", CLR_FC_ERROR), \
+ ASTATUS_FC(_a, LOGI_R, "login timed out, retrying", LINK_RESET), \
+ ASTATUS_FC(_a, CRC_T, "CRC threshold exceeded", LINK_RESET), \
+ ASTATUS_FC(_a, LOGO, "target initiated LOGO", 0), \
+ ASTATUS_FC(_a, OTHER, "other error", CLR_FC_ERROR | LINK_RESET)
+
+static const struct asyc_intr_info ainfo[] = {
+ BUILD_SISL_ASTATUS_FC_PORT(1),
+ BUILD_SISL_ASTATUS_FC_PORT(0),
+ BUILD_SISL_ASTATUS_FC_PORT(3),
+ BUILD_SISL_ASTATUS_FC_PORT(2)
+};
+
 /**
  * cxlflash_async_err_irq() - interrupt handler for asynchronous errors
  * @irq: Interrupt number.
@@ -1305,18 +1288,18 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
  struct afu *afu = (struct afu *)data;
  struct cxlflash_cfg *cfg = afu->parent;
  struct device *dev = &cfg->dev->dev;
- u64 reg_unmasked;
  const struct asyc_intr_info *info;
  struct sisl_global_map __iomem *global = &afu->afu_map->global;
  __be64 __iomem *fc_port_regs;
+ u64 reg_unmasked;
  u64 reg;
+ u64 bit;
  u8 port;
- int i;
 
  reg = readq_be(&global->regs.aintr_status);
  reg_unmasked = (reg & SISL_ASTATUS_UNMASK);
 
- if (reg_unmasked == 0) {
+ if (unlikely(reg_unmasked == 0)) {
  dev_err(dev, "%s: spurious interrupt, aintr_status=%016llx\n",
  __func__, reg);
  goto out;
@@ -1326,10 +1309,17 @@ static irqreturn_t cxlflash_async_err_irq(int irq, void *data)
  writeq_be(reg_unmasked, &global->regs.aintr_clear);
 
  /* Check each bit that is on */
- for (i = 0; reg_unmasked; i++, reg_unmasked = (reg_unmasked >> 1)) {
- info = find_ainfo(1ULL << i);
- if (((reg_unmasked & 0x1) == 0) || !info)
+ for_each_set_bit(bit, (ulong *)&reg_unmasked, BITS_PER_LONG) {
+ if (unlikely(bit >= ARRAY_SIZE(ainfo))) {
+ WARN_ON_ONCE(1);
  continue;
+ }
+
+ info = &ainfo[bit];
+ if (unlikely(info->status != 1ULL << bit)) {
+ WARN_ON_ONCE(1);
+ continue;
+ }
 
  port = info->port;
  fc_port_regs = get_fc_port_regs(cfg, port);
--
2.11.0


--
kernel-team mailing list
[hidden email]
https://lists.ubuntu.com/mailman/listinfo/kernel-team
123
Loading...